Case Study – NCache Provides Performance & Scalability to Top 5 Auto Maker

Introduction

Automobile Finance industry is one of the largest industries in the world. With a massive customer base, they have their network spread all over the world. One of the top five auto makers, with hundreds of dealers all across USA and tens of thousands of customers, needs high availability and scalability within their automobile finance applications for their everyday use. As a leading auto maker, their main goal is to provide a value service for their dealers and the end customers by providing a fast and reliable data access mechanism.

Their application is divided up into two parts. First is an interactive initiation system for customer facing self-service portal and second is a dealer facing portal for their financial service management. Financial services include loan management, payment plans, installment plans and contract management. The multiple systems handled by their application are:

• Initiation System: this serves the purpose of talking to the dealer & signing loan agreement for the purchase of an automobile.
• Contract Management System: an account management system that goes through the life span of the automobile.
• Customer Self-Service: a self-service portal for the customer which provides basic information about pricing and purchase details.

A diverse system with a large number of end users and multiple functionalities demand a high-speed data delivery along with consistency on their public facing site.

Challenges

With high transactional applications, the main challenge is to maintain fast speed and high availability of data. The application heavily relies on the backend relational database and it becomes a performance and scalability bottleneck under high transactional load. With hundreds of thousands of end-users, there is a high request load causing slow performances. Additionally, the end-users are located in different time zones. The load shifts over regions thus causing increased transactional loads on the database. It results in a negative impact on the user and an associated business cost.

Other than that, with large data objects the data transmission over the network becomes very slow. The network trips are very costly for large data objects and it affects the overall performance of the application. Static data can be kept in-memory to avoid the database trips every time a request is made. This reduces the network trips as they are expensive in nature. However, the in-memory data needs to be synchronized with the database as there are two separate copies of the data and they can fall out of sync. Thus, data synchronization is another challenge their application is facing.

Client Cache for InProc Speed

The customer portal displays information about the prices of the cars and the details such as manufacturing details and model etc. The catalogue displays the pictures of the vehicles along with vehicle details. This data is mostly static and some of it is large in size as well which makes it expensive to fetch from database for individual requests. So, caching the static data for usage enhances the user experience as the response time is better along with the application performance.

NCache provides a specialized feature called Client Cache that is ideal for caching static data. Client Cache allows them to keep data locally on the application servers (closer to the application) and helps them save expensive network trips in addition to expensive database trips that NCache was already saving for them. Client Cache is also synchronized with their remote clustered cache that ensures data consistency while improving application performance.

Client cache also resolves the performance issues associated with large data objects. Client Cache originally resides these large objects locally on the same client machine hence, saving the back and forth network trips. The application experiences a lot faster data retrieval with NCache client cache.

In addition to Client cache, it is also recommended that they turn on compression to reduce the size of the object to further tune the performance.

Cache Loader for Pre-Loading the Cache

With caching, the application first checks for the data in the cache for example, in order to view the price details the cache is checked first for pre-calculated pricing data. If the cache fails to provide with the required data, the data is looked for in the database. It is then saved in the cache for future usage. It improves the application performance but it costs a database trip for every data item that is not cached.

This problem is handled using the Cache Startup Loader. It pre-loads most of the data in the cache on startup as most of their data is static. It makes the data highly available and saves the network cost. In the above example, for pricing details which require fast data loading, the cache will always retain the data. It is of great help for further improving the application performance and handling the request throughput.

Synchronizing Cache with SQL Server

NCache retains the data from the database and keeps it for usage. It improves the throughput and performance of the application. However, for two separate copies of data, synchronization is a major necessity. If the data in the database is updated, the cache data becomes stale and the application keeps using the stale data. In order to keep the cache and database synchronized, NCache provides with a feature of database synchronization which keeps the data in the both the data sources consistent. For any change in the database, the data in cache automatically gets removed and fetches the latest copy of data, the next time it is asked for. This way, the application will always perform operations on the updated data set.

Moving Forward with NCache

The automobile finance company is benefitting from NCache in a lot of areas as discussed above and moving further, they are looking forward to use Microservices architecture with NCache. They have decided to enhance NCache usage further for their mission critical Microservices applications for a higher uptime across all user regions. "I am really hoping that we can move something fairly easy next and we start taking advantage of some advanced features of NCache", said one of the architects of the team.

They are planning to use .NET Core with Kubernetes for this application which NCache fully supports. They have also shown their interest in event driven Pub/Sub messaging feature of NCache to provide communication between their microservices. NCache is able to manage all of this for them (.NET Core, Containerization, Event Driven Pub/Sub Messaging) while managing super-fast performance and extreme scalability.

What to Do Next?

• NCache Details
• Download NCache
• Request a Personalized LIVE Demo