All 15 Caching questions
More in Caching
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 is cache stampede (thundering herd), and how do you prevent it in a high-traffic Node.js service? 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 “SQL/Sequelize)”
Node.js › Caching

What are the main cache invalidation strategies (TTL, write-through, cache-aside), and when is each appropriate?

Advanced

Answer

Time-to-live (TTL) expiration simply lets cached entries expire automatically after a fixed duration -- simple, but can serve stale data until expiration. Cache-aside (lazy loading) has the application check the cache first, falling back to the source and populating the cache on a miss -- flexible, but the first request after a miss pays the full latency cost. Write-through updates the cache synchronously every time the underlying data is written, keeping the cache always consistent at the cost of added write latency and complexity.
// Cache-aside pattern
async function getProduct(id) {
  let product = await redis.get(`product:${id}`);
  if (!product) {
    product = await db.products.findById(id);
    await redis.set(`product:${id}`, JSON.stringify(product), { EX: 600 });
  }
  return typeof product === 'string' ? JSON.parse(product) : product;
}

// Write-through: update cache and DB together on every write
async function updateProduct(id, data) {
  await db.products.update(id, data);
  await redis.set(`product:${id}`, JSON.stringify(data), { EX: 600 });
}
Real-world example A pricing service uses write-through caching specifically for currency exchange rates (needing immediate consistency everywhere), but uses simple cache-aside with a short TTL for less critical, less frequently accessed product descriptions.

Common follow-ups: What is the 'thundering herd' problem with TTL-based caching, and how do you mitigate it?;How would you combine cache-aside with an explicit invalidation event to get both simplicity and freshness?

Databases & ORMs (MongoDB/Mongoose SQL/Sequelize);Message Queues (RabbitMQ & Kafka)
All 15 Caching questions