All 15 Caching questions
More in Caching
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 Redis's EXPIRE and how do TTL-based keys interact with Redis's own memory eviction policies under memory pressure? What is the 'stale-while-revalidate' caching strategy, and how would you implement it for an API response? What is multi-tier caching (combining an in-memory L1 cache with a distributed L2 cache), and what problem does it solve? How would you implement a write-behind (write-back) caching strategy, and what durability risk does it introduce?
Advertisement
Back to results for “Performance Optimization & Profiling”
Node.js › Caching

What is cache stampede (thundering herd), and how do you prevent it in a high-traffic Node.js service?

Advanced

Answer

Cache stampede occurs when a popular cached entry expires and many concurrent requests simultaneously discover the cache miss and all rush to recompute the same expensive underlying data at once, momentarily overwhelming the downstream database exactly as if the cache didn't exist. Common mitigations include using a lock or 'in-flight request' map so only the first request actually recomputes the value while others wait for that same result, and 'stale-while-revalidate' -- serving the slightly stale cached value immediately while refreshing it in the background.
const inFlight = new Map();

async function getWithStampedeProtection(key, fetchFn) {
  if (inFlight.has(key)) return inFlight.get(key); // join the existing in-flight fetch
  const promise = fetchFn().finally(() => inFlight.delete(key));
  inFlight.set(key, promise);
  return promise;
}
Real-world example A news site's homepage data cache expiring during a traffic spike used to cause a brief but severe database overload; adding an in-flight deduplication map ensures only one regeneration happens per expiration, with all other concurrent requests simply awaiting that same result.

Common follow-ups: How does 'stale-while-revalidate' differ from the in-flight deduplication approach, and could they be combined?;What's the risk of the in-flight deduplication approach if the single in-progress fetch itself hangs or fails?

Performance Optimization & Profiling;Error Handling
All 15 Caching questions