Comprehensive Cache Architecture: Patterns, Invalidation, and High-Scale Pitfalls

+-------------+      1. Read Cache      +-------------+
| Application | ----------------------> |    Redis    |
+-------------+                         +-------------+
       |                                       |
       | 2. Cache Miss                         | Return Data
       v                                       v
+-------------+
|  Database   |
+-------------+

1. Cache Stampede (Thundering Herd)
   Key expires -> 10,000 concurrent requests all miss -> 10,000 queries hit DB simultaneously -> DB CRASH!
   Fix: Mutex Lock / Singleflight pattern or probabilistic early expiration (XFetch).

2. Cache Penetration
   Requests for non-existent IDs bypass cache completely and hit DB continuously.
   Fix: Store null values with short TTL, or use Bloom Filters.

3. Cache Avalanche
   Thousands of keys set with the exact same 3600s TTL expire at the exact same second.
   Fix: Add random jitter to TTLs: TTL = 3600 + Math.floor(Math.random() * 300).

async function getWithMutex(key: string, fetchDb: () => Promise<any>, ttlSeconds: number) {
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

  const lockKey = `lock:${key}`;
  const acquired = await redis.set(lockKey, "1", "NX", "EX", 10);

  if (acquired) {
    try {
      const data = await fetchDb();
      await redis.set(key, JSON.stringify(data), "EX", ttlSeconds);
      return data;
    } finally {
      await redis.del(lockKey);
    }
  } else {
    // Wait briefly and retry from cache
    await new Promise((resolve) => setTimeout(resolve, 50));
    return getWithMutex(key, fetchDb, ttlSeconds);
  }
}