Redis for distributed caching in Node.js - Step-by-Step Execution

Concept Flow - Redis for distributed caching

App requests data

↓

Check Redis cache

↓

Return cached

↓

Send response

The app first checks Redis cache for data. If found, it returns cached data. If not, it fetches from database, stores it in Redis, then returns it.

Execution Sample

Node.js

const redis = require('redis');
const client = redis.createClient();

client.connect();

async function getData(key) {
  const cache = await client.get(key);
  let data;
  if (cache) {
    data = JSON.parse(cache);
  } else {
    data = await fetchFromDB(key);
    await client.set(key, JSON.stringify(data));
  }
  return data;
}

This code tries to get data from Redis cache first; if missing, it fetches from DB, caches it, then returns.

Execution Table

Step	Action	Redis GET Result	DB Fetch	Redis SET	Return Value
1	Call getData('user:1')	null	No	No	No
2	Redis GET 'user:1'	null	No	No	No
3	Cache miss, fetch from DB	null	User data from DB	No	No
4	Store data in Redis	null	User data from DB	Set user:1	No
5	Return fetched data	null	User data from DB	Set user:1	User data from DB
6	Call getData('user:1') again	User data JSON	No	No	No
7	Redis GET 'user:1'	User data JSON	No	No	No
8	Cache hit, parse and return	User data JSON	No	No	User data from cache

💡 Execution stops after returning data from cache or DB.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 8
cache	undefined	null	null	User data JSON string
data	undefined	User data from DB	User data from DB	User data from cache (parsed)

Key Moments - 3 Insights

Why do we check Redis before fetching from the database?

Because Redis is a fast cache; checking it first avoids slow database calls if data is already cached, as shown in execution_table steps 2 and 7.

What happens if Redis returns null?

It means cache miss; then the code fetches data from the database and stores it in Redis, as seen in steps 3 and 4.

Why do we store data in Redis after fetching from DB?

To speed up future requests by caching the data, so next time Redis GET returns the data directly, shown in step 4 storing and step 8 returning.

Visual Quiz - 3 Questions

Look at the execution_table, what is the Redis GET result at step 7?

A Error

B null

C User data JSON

D Undefined

💡 Hint

Check the 'Redis GET Result' column at step 7 in the execution_table.

At which step does the code fetch data from the database?

A Step 2

B Step 3

C Step 6

D Step 8

💡 Hint

Look for the 'DB Fetch' column showing 'User data from DB' in the execution_table.

If Redis always returns data, which steps would be skipped?

A Steps 3 and 4

B Steps 1 and 2

C Steps 5 and 6

D Steps 7 and 8

💡 Hint

Refer to execution_table steps where DB fetch and Redis set happen.

Concept Snapshot

Redis caching flow:
1. App requests data.
2. Check Redis cache with GET.
3. If cache miss, fetch from DB.
4. Store DB data in Redis with SET.
5. Return data to app.
This speeds up repeated data access.

Full Transcript

This visual execution shows how Redis is used for distributed caching in a Node.js app. When the app requests data, it first checks Redis cache using GET. If Redis returns null, it means the data is not cached, so the app fetches it from the database. Then, it stores the fetched data in Redis using SET for future fast access. If Redis returns data, the app parses and returns it immediately, avoiding a database call. This process improves performance by reducing database load and speeding up data retrieval.