How do you invalidate a cache without serving stale data?

There are only two hard problems in cache invalidation: knowing when data changed and coordinating that change across every cache layer. TTLs bound staleness but do not make data fresh. Explicit invalidation improves freshness but adds coupling between the writer and the cache.

async function updateUser(id, patch) {
  const user = await db.user.update({
    where: { id },
    data: patch,
  });

  await redis.del("user:" + id);
  await redis.del("user:" + id + ":profile");

  return user;
}

Strategies and races

• TTL-only invalidation is simple and tolerates bounded staleness
• Delete on write, then let the next read repopulate the cache
• Write-through keeps the cache and database in step but adds write latency
• Versioned keys make old entries unreachable when a schema or dataset changes
• Event-driven invalidation through a queue decouples writers but introduces delay
• A read that started before a write can repopulate stale data after the delete

The classic race is a reader that misses, queries the old value, then writes it back after the writer has already deleted the key. Mitigations include a short delete-after-write delay, versioned keys, or a lock around the miss. No approach is perfect without stronger coordination; choose based on how bad stale data is.