How To Build a Caching System Through Redis in Node JS?

In today’s world, you don’t want your application to be slow. If a website is taking too long to respond there might be a chance the user will not visit your application again and Boosting node js application.

In this article, we are going to implement the caching system through Redis in NodeJS. But before learning that we have to understand what exactly caching is, how it increases the performance of the website, and how to scale the node js application. Also, we have mentioned how we can use Redis in our application. 

What is Caching? 

Caching is the process where we store the regularly used data in an In-Memory Database. Suppose we are accessing a certain page regularly, we store the data of that page in the Redis database so that we can cache it, boosting node js application.

Why do we need Caching?

Some reasons to cache your node js application:- 

  • If you want to reduce the response time for a node js application you can use caching

To summarize, caching is a win-win situation for your customer and yourself as it reduces the cost of managing a website.

How to Scale Your NodeJS Application?

To follow the tutorial, you must install these software and packages on your operating system:- 

  • NodeJS: Open Source Library to run web server
  • NPM:- Node Package Manager to install Packages
  • Postman:- Postman is a tool for API Testing
  • Code Editor(VS Code):- For this application, we are using VS Code as an Editor

Make sure you have installed the NodeJS Application on your system. If you don’t have NodeJS you can go to the NodeJS Website to install the Application. After installing NodeJS NPM will be installed automatically. 

Getting Started:- 

To get started, create a new directory in your root folder by running the following commands:- 

  1. mkdir cache-app && cd cache-app  

Initialize your package.json file by running the following command:- 

npm init -y

Make sure you install Redis, Axios, and express packages using Node package manager(NPM)

npm install axios redis express

Axios :- Axios is a package to make a network request to node js backend

Redis:- Package which we are using for caching

Express:- Package used for creating a web server

Create a simple Express server application:- 

Now we will be going to request the food recipe API for various food items

In your index.js paste the following code 

const express = require('express'); const app = express(); const port = 3000; const axios = require('axios'); app.get('/recipe/:fooditem', async (req, res) => { try { const food item = req. item; const recipe = await Axios.get(`${fooditem}`); return res.status(200).send({ error: false, data: recipe. data.results }); } catch (error) { console.log(error); } }); app.listen(port, () => { console.log(`Server running on port ${port}`); }); module.exports = app;
Code language: JavaScript (javascript)

This piece of code is making a request to the food recipe API with the use of Axios library about a specific food item.

Now start the server by running the command node index.js test your open postman and make a request to the food recipe endpoint.

As you can see the request that we have made is taking a significant time of 615ms which is not good for any website. We will improve this by using Redis Cache.

Add the following code to your index.js file to enable Caching

const express = require(‘express’); const axios = require(‘axios’); const redis = require(‘redis’); const app = express(); const port = 3000; const client = redis.createClient(6379); client.on(“error”, (error) => { console.error(error); }); app.get(‘/recipe/:fooditem’, (req, res) => { try { const foodItem = req. item; client.get(foodItem, async (err, recipe) => { if (recipe) { return res.status(200).send({ error: false, message: `Recipe for ${foodItem}`, data: JSON.parse(recipe) }) } else { const recipe = await axios.get(`${foodItem}`); client.setex(foodItem, 1440, JSON.stringify(; return res.status(200).send({ error: false, message: `Recipe for ${foodItem} from the server`, data: recipe. data.results }); } }) } catch (error) { console.log(error) } }); app.listen(port, () => { console.log(`Server running on port ${port}`); }); module.exports = app;
Code language: JavaScript (javascript)

First, using the standard Redis port (6379), we constructed a Redis client and connected it to the local Redis instance.

Then, using the key from our Redis store, we attempted to find the correct matching data to fulfill the request in the /recipe route handler. If the result is found, it is delivered to the client requesting our cache, saving us from making another server request.

However, if the key is not present in our Redis store, a request is sent to the server, and when the server responds, the result is stored using a special key in the Redis store.

So long as the cached data hasn’t expired, subsequent requests to the same endpoint with the same parameter will always be fetched from the cache. The key is set to hold a string value in the store for a specific amount of seconds, in this example 1440 (24 minutes), using the Redis client’s set method.

Now we can test the application and it will take less time to make the second request to the web server.


I hope you have learned from the article how we can use Redis in our application. As a developer, you will use Redis in many applications like if you are building a chat application or any web server and it improves the web performance. So as a developer, everyone should learn Redis. Thank You!!!

Recent Post

  • How to Implement File Uploads in Node.js with Multer?

    For many web applications that let users share papers, photos, and other types of material, file uploads are a necessary functionality. Multer is a well-liked middleware used for Handling file uploads in Node.js using Multer the Node.js environment to effectively handle file uploads. We’ll look at how to use Multer to create file uploads […]

  • How to Use Local Storage to Persist Data in a JavaScript Application?

    Data persistence is a key aspect of web applications. In JavaScript, one of the primary tools for achieving this is Local Storage, a part of the Web Storage API. This JavaScript data persistence tool provides a simple key-value storage mechanism within the user’s browser. Unlike session storage, which persists data only during a session, Local […]

  • How to Use WordPress API?

    WordPress stands out as a leading content management system, celebrated for its dynamic capabilities in website and blog development. Renowned for its rich feature set and extensive customization options, WordPress empowers creators to fashion captivating online experiences. In recent times, WordPress has expanded its horizons into the realm of APIs, granting developers a potent tool […]

  • How to Use Post and Pre Hooks in Mongoose?

    In Mongoose, a widely-used library for working with MongoDB, there are valuable tools called “Pre and Post Hooks.” These hooks, also known as “Mongoose Middleware” or “Mongoose Model Hooks,” allow developers to run their own code just before or after specific actions on the database. With “Pre Hooks,” you can customize actions before they happen, […]

  • How To Create Reusable Components in React: Best Practices

    Rеact is a popular library for building usеr intеrfacеs with JavaScript. One of the main benefits of Rеact is its ability to create reusable componеnts that can be used in different parts of your application. Reusable componеnts can help you savе timе, rеducе codе duplication, and еnsurе consistеncy in your UI. However, creating rеusablе componеnts […]

  • Implementing Higher Order Components in Class-Based Components for Code Reusability in ReactJS

    Rеact is a powerful library for building usеr intеrfacеs, and one of its corе strengths liеs in its componеnt-basеd architеcturе. Componеnts arе thе building blocks of Rеact applications, and thеy allow you to crеatе modular and rеusablе piеcеs of UI. Howеvеr, as your application grows, you may find thе nееd for rеusing cеrtain functionalitiеs across […]