Caching in Node.js with Redis: A Beginner’s Guide

Caching is a technique to store frequently used data in a temporary storage so that future requests for that data are faster. In Node.js applications, caching can help improve performance and reduce the load on your database. One popular tool for caching is Redis.
In this blog, we will learn what caching is, why it is useful, and how to implement caching in a Node.js application using Redis.

What is Redis?

Redis is an in-memory data store that can be used as a database, cache, or message broker. Being in-memory makes it extremely fast compared to querying a traditional database. Redis supports different data structures like strings, hashes, lists, and sets.

Why Use Caching?

Imagine your Node.js app queries a database every time a user requests a page. If thousands of users request the same data, your database will be overloaded, and response time will be slow.
Caching solves this problem by storing the response in memory. So, if the same request comes again, the app can serve the cached response instead of querying the database again.
Benefits of caching:

• Faster response times
• Reduced database load
• Improved scalability

Setting Up Redis with Node.js

Step 1: Install Redis
First, install Redis on your machine. You can download it from https://redis.io/download. If you are using Docker, you can run:
docker run –name redis-cache -p 6379:6379 -d redis

Step 2: Install Redis Client in Node.js
We will use the redis npm package:
npm install redis

Example: Caching API Data with Redis
Here’s a simple example where we cache API responses for 10 seconds:

const express = require('express');
const redis = require('redis');

const app = express();
const PORT = 3000;

// Connect to Redis
const client = redis.createClient();

client.on('error', (err) => console.log('Redis Client Error', err));

app.get('/data', async (req, res) => {
const cacheKey = 'myData';

// Check if data is in cache
client.get(cacheKey, async (err, cachedData) => {
if (err) throw err;

if (cachedData) {
console.log('Serving from cache');
return res.send(JSON.parse(cachedData));
}

// Simulate database call
const data = {
message: 'Hello, this is your data!',
timestamp: new Date(),
};

// Store data in Redis cache for 10 seconds
client.setex(cacheKey, 10, JSON.stringify(data));

console.log('Serving from database');
res.send(data);
});
});

app.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});

How it Works:

1. When a request comes to /data, we first check if the response is in Redis.
2. If yes, we return the cached data.
3. If not, we fetch the data (here simulated with a static object), save it in Redis for 10 seconds, and then return it.

Tips for Using Redis Caching

1. Set Expiry Time – Always set a TTL (time to live) for cached data to avoid stale data.
2. Cache Only Frequently Used Data – Don’t cache everything. Focus on endpoints or queries that are heavy and frequently requested.
3. Handle Cache Misses – Always have a fallback mechanism if Redis is down.

Summary:

Caching with Redis is a simple way to boost your Node.js app performance. By storing frequently requested data in memory, you reduce database load and make your application faster.
Even a small caching setup can make a big difference, especially for apps with heavy database operations or high traffic.