How to Implement Caching in Node.js with Redis

Every time a client requests data, your server queries the database, processes the result, and sends a response. If the same data is requested thousands of times per minute and it does not change frequently, you are performing the same expensive database query thousands of times unnecessarily. Caching stores the result of a query in fast memory so subsequent identical requests are served instantly without touching the database.

Redis is an in-memory key-value data store known for sub-millisecond response times. It stores data in RAM rather than on disk, making reads and writes extremely fast. Redis supports expiration times on keys, meaning cached data automatically disappears after a specified duration. It is the most popular caching solution used in production Node.js applications.

Install the ioredis package which is a robust Redis client for Node.js. Create a Redis client instance by instantiating ioredis with your Redis connection URL. The client automatically manages reconnections and connection pooling. Store the client instance in a module and export it so it is shared across your application rather than creating a new connection for every request.

A cache key uniquely identifies a specific piece of cached data. Design descriptive, hierarchical key names. For a user profile, use a key like 'user:123:profile'. For a paginated list of products in category 5, use 'products:category:5:page:2'. Consistent naming makes it easy to target specific cached data for invalidation when the underlying data changes.

In the cache-aside pattern, the application first checks the cache for the requested data. If the data exists in the cache, return it immediately without querying the database. If the data is not in the cache, query the database, store the result in the cache with an expiration time, and then return the result to the client. This is the most common caching pattern for read-heavy applications.

Create an Express middleware that accepts a TTL parameter for expiration time. Inside the middleware, construct the cache key from the request URL and any relevant parameters. Call redis.get with the key. If the cached value exists, parse it and send it as the response immediately. If not, call next to proceed to the route handler and intercept the response to store it in Redis before sending it to the client.

Cached data becomes stale when the underlying database record changes. When a user updates their profile, delete the corresponding cache key using redis.del so the next request fetches fresh data from the database. For invalidating groups of related keys, use Redis SCAN with a pattern or structure your keys to use a common prefix and delete by prefix.

Your application must work correctly even if Redis is temporarily unavailable. Wrap all Redis operations in try-catch blocks. If a Redis read fails, proceed to query the database and serve the request normally. If a Redis write fails, still send the response to the client. Log the Redis error for monitoring but never let a cache failure cause the entire request to fail. Redis should accelerate your application, not be a dependency it cannot survive without.