All 15 Caching questions
More in Caching
What is caching, and why is it commonly used to improve the performance of a Node.js application? What is the difference between res.set('Cache-Control', 'no-cache') and 'no-store' in an Express response? What HTTP caching headers (Cache-Control, ETag) can a Node.js/Express API use to let clients and CDNs cache responses? How would you implement a Least Recently Used (LRU) cache in Node.js, and why is eviction necessary for an in-memory cache? What is memoization, and how does it differ from a general-purpose external cache like Redis? How would you cache the result of a database query in Node.js while ensuring the cache is properly invalidated when the underlying data changes? What is the risk of caching sensitive or user-specific data with a shared cache key, and how do you avoid it? What is negative caching, and why might you deliberately cache the fact that a lookup returned 'not found'? What are the main cache invalidation strategies (TTL, write-through, cache-aside), and when is each appropriate? What is cache stampede (thundering herd), and how do you prevent it in a high-traffic Node.js service?
Advertisement
Node.js › Caching

What is the difference between in-memory caching (like a Map or node-cache) and a distributed cache (like Redis)?

Intermediate

Answer

An in-memory cache lives entirely within a single Node.js process's memory -- extremely fast with no network overhead, but limited to that one process (useless once an application scales to multiple instances) and lost entirely on restart. A distributed cache like Redis runs as a separate shared service that all application instances connect to, providing a single consistent cache shared across every instance, at the cost of network latency per access and an additional piece of infrastructure.
// In-memory: fast, but each of N server instances has its own separate cache
const cache = new Map();

// Distributed: one shared cache across every instance
const redis = require('redis').createClient();
await redis.set(`user:${id}`, JSON.stringify(user), { EX: 3600 });
const cached = await redis.get(`user:${id}`);
Real-world example A service running behind a load balancer with five instances switches from an in-memory Map cache to Redis, since with the in-memory approach a cache-invalidation event on one instance had no way to also clear the stale entry sitting in the other four instances' separate caches.

Common follow-ups: What's a hybrid caching strategy that uses both layers together, and why might that be worth the added complexity?;How does Redis's own memory limit and eviction policy affect what you can safely rely on it for?

Caching with Redis;Cloud & DevOps
All 15 Caching questions