In-memory caching with node-cache in Express - Performance & Optimization

Performance: In-memory caching with node-cache

MEDIUM IMPACT

This concept affects server response time and reduces backend processing load, improving how fast pages or data are served to users.

Serving frequently requested data in an Express app

Express

import NodeCache from 'node-cache';
const cache = new NodeCache({ stdTTL: 60 });

app.get('/data', (req, res) => {
  const cachedData = cache.get('data');
  if (cachedData) {
    return res.json(cachedData);
  }
  fetchFromDatabase().then(data => {
    cache.set('data', data);
    res.json(data);
  });
});

Data is stored in memory for 60 seconds, so repeated requests return instantly without hitting the database.

📈 Performance GainReduces server processing time and database queries, improving response time and lowering server load.

Serving frequently requested data in an Express app

Express

app.get('/data', async (req, res) => {
  const data = await fetchFromDatabase();
  res.json(data);
});

Every request queries the database, causing slow responses and high server load.

📉 Performance CostBlocks response for each request; increases server CPU and database load.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
No caching - fetch on every request	N/A (server-side)	N/A	N/A	[X] Bad
In-memory caching with node-cache	N/A (server-side)	N/A	N/A	[OK] Good

Rendering Pipeline

In-memory caching reduces backend processing before the response reaches the browser, speeding up the critical rendering path by delivering data faster.

→Server Processing

→Network Transfer

→First Paint

⚠️ BottleneckServer Processing (database queries and data fetching)

Core Web Vital Affected

LCP

This concept affects server response time and reduces backend processing load, improving how fast pages or data are served to users.

Optimization Tips

1Cache frequently requested data in memory to reduce backend load.

2Set appropriate cache expiration to balance freshness and performance.

3Use caching to improve server response time and reduce LCP.

Performance Quiz - 3 Questions

What is the main performance benefit of using in-memory caching with node-cache in an Express app?

A Reduces repeated database queries and speeds up response time

B Increases the size of the client-side bundle

C Triggers more DOM reflows in the browser

D Improves CSS selector performance

DevTools: Network

How to check: Open DevTools, go to Network tab, reload the page or API call, and check response times and status codes.

What to look for: Look for faster response times and fewer requests hitting the backend when caching is enabled.

Practice

1. What is the main purpose of using node-cache in an Express app?

easy

A. To permanently save data to a database

B. To temporarily store data in memory for faster access

C. To handle user authentication securely

D. To serve static files like images and CSS

Solution

1. Step 1: Understand what caching means

   Caching means storing data temporarily to avoid repeated slow operations.

2. Step 2: Identify node-cache role in Express

   node-cache stores data in memory temporarily to speed up data retrieval.

3. Final Answer:

   To temporarily store data in memory for faster access -> Option B

4. Quick Check:

   In-memory caching = temporary fast storage [OK]

Hint: Cache stores data temporarily to speed up access [OK]

Common Mistakes:

• Confusing cache with permanent database storage
• Thinking node-cache handles authentication
• Assuming node-cache serves static files

2. Which of the following is the correct way to create a new cache instance using node-cache?

easy

A. const cache = new nodeCache();

B. const cache = nodeCache.create();

C. const cache = new NodeCache();

D. const cache = NodeCache();

Solution

1. Step 1: Recall node-cache import and usage

   node-cache is imported as NodeCache and instantiated with new keyword.

2. Step 2: Check syntax correctness

   Correct syntax is: const cache = new NodeCache();

3. Final Answer:

   const cache = new NodeCache(); -> Option C

4. Quick Check:

   Use new NodeCache() to create cache [OK]

Hint: Use 'new' keyword with NodeCache class [OK]

Common Mistakes:

• Calling nodeCache.create() which does not exist
• Using lowercase 'nodeCache' instead of 'NodeCache'
• Omitting 'new' keyword when creating instance

3. Given the code snippet below, what will be the output when accessing /data twice quickly?

const express = require('express');
const NodeCache = require('node-cache');
const app = express();
const cache = new NodeCache();

app.get('/data', (req, res) => {
  const cached = cache.get('myData');
  if (cached) {
    res.send('From cache: ' + cached);
  } else {
    const freshData = 'Hello World';
    cache.set('myData', freshData, 10);
    res.send('Fresh data: ' + freshData);
  }
});

app.listen(3000);

medium

A. First request: Fresh data: Hello World; Second request: From cache: Hello World

B. Both requests: Fresh data: Hello World

C. Both requests: From cache: Hello World

D. First request: From cache: Hello World; Second request: Fresh data: Hello World

Solution

1. Step 1: Analyze cache check on first request

   Cache is empty initially, so first request sets and returns fresh data.

2. Step 2: Analyze cache check on second request

   Second request finds data in cache and returns cached data.

3. Final Answer:

   First request: Fresh data: Hello World; Second request: From cache: Hello World -> Option A

4. Quick Check:

   Cache empty first, then hit cache second [OK]

Hint: First request sets cache, second reads from cache [OK]

Common Mistakes:

• Assuming cache is always empty
• Thinking cache returns fresh data every time
• Mixing order of fresh and cached responses

4. Identify the error in this code snippet using node-cache in Express:

const NodeCache = require('node-cache');
const cache = NodeCache();

app.get('/item', (req, res) => {
  const item = cache.get('itemKey');
  if (!item) {
    cache.set('itemKey', 'value');
    res.send('Set new item');
  } else {
    res.send('Cached item: ' + item);
  }
});

medium

A. Cache key 'itemKey' is invalid

B. Express app is not imported

C. cache.set requires a callback function

D. Missing 'new' keyword when creating cache instance

Solution

1. Step 1: Check cache instance creation

   node-cache requires 'new NodeCache()' to create an instance.

2. Step 2: Identify missing 'new' keyword

   Code uses 'NodeCache()' without 'new', causing error.

3. Final Answer:

   Missing 'new' keyword when creating cache instance -> Option D

4. Quick Check:

   Always use 'new' with NodeCache [OK]

Hint: Remember 'new' keyword for NodeCache instance [OK]

Common Mistakes:

• Forgetting 'new' keyword
• Thinking cache.set needs callback
• Assuming cache keys must be special format

5. You want to cache user profile data for 5 minutes using node-cache. Which code snippet correctly sets the cache with expiration and retrieves it safely in Express?

hard

A. cache.set('user1', profile, 300); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

B. cache.set('user1', profile); const data = cache.get('user1', 300); if (data) res.send(data); else res.send('No cache');

C. cache.set('user1', profile, 5); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

D. cache.set('user1', profile, 300000); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

Solution

1. Step 1: Understand TTL unit in node-cache

   TTL (time to live) is in seconds, so 5 minutes = 300 seconds.

2. Step 2: Check correct usage of set and get

   cache.set(key, value, ttl) sets with expiration; cache.get(key) retrieves value.

3. Final Answer:

   cache.set('user1', profile, 300); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache'); -> Option A

4. Quick Check:

   TTL in seconds, set with 300 for 5 minutes [OK]

Hint: TTL is seconds; 5 minutes = 300 seconds [OK]

Common Mistakes:

• Using TTL in milliseconds instead of seconds
• Passing TTL to get() method incorrectly
• Setting TTL too low (5 seconds instead of 300)