Cache stampede prevention in HLD - System Design Exercise

Design: Cache Stampede Prevention System

Design focuses on cache layer and backend interaction to prevent stampede. Out of scope: detailed backend business logic, frontend UI design.

Functional Requirements

FR1: Prevent multiple requests from overwhelming the backend when cache expires

FR2: Serve cached data with low latency for read-heavy workloads

FR3: Ensure data consistency between cache and backend

FR4: Handle sudden spikes in traffic gracefully

FR5: Support cache expiration and refresh without blocking user requests

Non-Functional Requirements

NFR1: Support up to 50,000 concurrent users

NFR2: API response latency p99 under 150ms

NFR3: Availability target of 99.9% uptime

NFR4: Cache expiration time configurable between 1 minute to 1 hour

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Cache storage (Redis or Memcached)

Backend data source (database or API)

Locking mechanism (distributed locks or mutex)

Request queue or token bucket for throttling

Cache refresh logic (lazy or proactive)

Design Patterns

Cache-aside pattern

Mutex lock or distributed lock for cache rebuild

Request coalescing to combine multiple cache misses

Early recomputation (refresh before expiry)

Probabilistic early expiration

Reference Architecture

Application Servers

↓

Cache Layer (Redis)

↓

Backend Database

Components

Cache Layer

Redis

Store cached data with expiration and support atomic operations for locking

Distributed Lock Service

Redis Redlock or Zookeeper

Coordinate locks to allow only one process to rebuild cache at a time

Backend Database

Relational or NoSQL DB

Source of truth for data to refresh cache

Application Servers

Stateless servers

Serve client requests, check cache, acquire lock if needed, rebuild cache

Request Flow

1. Client sends request to Application Server

2. Application Server checks Redis cache for data

3. If cache hit, return data immediately

4. If cache miss or expired, Application Server tries to acquire distributed lock

5. If lock acquired, Application Server fetches fresh data from Backend Database

6. Application Server updates cache with fresh data and releases lock

7. If lock not acquired, Application Server waits or returns stale cache data if available

8. Client receives data with minimal delay and backend is protected from overload

Database Schema

Entity: DataItem { id (PK), value, last_updated } Relationships: None needed for cache stampede prevention; focus is on cache and locking coordination.

Scaling Discussion

Bottlenecks

Distributed lock contention under very high cache miss rates

Backend database overload if many cache rebuilds happen simultaneously

Cache storage limits and eviction policies under heavy load

Network latency between application servers and cache or lock service

Solutions

Use efficient distributed lock algorithms like Redlock with timeouts

Implement request coalescing to batch cache rebuild requests

Use early recomputation to refresh cache before expiry to reduce misses

Scale backend database with read replicas and caching layers

Partition cache keys to reduce lock contention

Use local caches with TTL to reduce load on central cache

Interview Tips

Time: Spend 10 minutes understanding requirements and clarifying constraints, 20 minutes designing the architecture and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing.

Explain the cache stampede problem clearly with real-life analogy (e.g., many people trying to enter a store after it opens)

Describe how distributed locks prevent multiple cache rebuilds

Discuss trade-offs between latency and data freshness

Mention fallback strategies like serving stale data

Highlight scaling challenges and mitigation techniques

Show awareness of failure modes like lock failures or cache inconsistencies

Practice

1. What is the main goal of cache stampede prevention in system design?

easy

A. To prevent many requests from hitting the database simultaneously

B. To increase the size of the cache storage

C. To reduce the number of cache servers

D. To encrypt cached data for security

Solution

1. Step 1: Understand cache stampede problem

   Cache stampede happens when many requests try to fetch data from the database because the cache expired or missed.

2. Step 2: Identify the goal of prevention

   The goal is to stop all these requests from hitting the database at once to avoid overload.

3. Final Answer:

   To prevent many requests from hitting the database simultaneously -> Option A

4. Quick Check:

   Cache stampede prevention = prevent database overload [OK]

Hint: Focus on reducing database hits during cache misses [OK]

Common Mistakes:

• Confusing cache size with stampede prevention
• Thinking encryption is related to stampede
• Assuming reducing cache servers helps stampede

2. Which of the following is a common technique used to prevent cache stampede?

easy

A. Storing data only in the database

B. Increasing cache TTL to infinite

C. Disabling cache for all requests

D. Using distributed locks around cache refresh

Solution

1. Step 1: Review common stampede prevention methods

   Techniques include locking, early expiration, and request coalescing to control cache refresh.

2. Step 2: Match technique to options

   Distributed locks prevent multiple processes from refreshing cache simultaneously, stopping stampede.

3. Final Answer:

   Using distributed locks around cache refresh -> Option D

4. Quick Check:

   Locking = stampede prevention [OK]

Hint: Look for locking or coordination methods in options [OK]

Common Mistakes:

• Choosing infinite TTL which can cause stale data
• Disabling cache which increases load
• Ignoring locking as a prevention method

3. Consider this pseudo-code for cache stampede prevention:

if cache miss:
  acquire lock
  if cache still miss:
    data = fetch from DB
    update cache
  release lock
return cached data

What happens if the lock is not used here?

medium

A. Multiple requests fetch from DB simultaneously causing overload

B. Cache never updates and returns stale data

C. Requests wait indefinitely causing deadlock

D. Cache size increases exponentially

Solution

1. Step 1: Analyze the role of the lock

   The lock ensures only one request fetches data from DB and updates cache on miss.

2. Step 2: Consequence of missing lock

   Without lock, many requests detect cache miss and all fetch from DB, causing overload.

3. Final Answer:

   Multiple requests fetch from DB simultaneously causing overload -> Option A

4. Quick Check:

   No lock = DB overload [OK]

Hint: Lock prevents simultaneous DB fetch on cache miss [OK]

Common Mistakes:

• Thinking cache never updates without lock
• Confusing deadlock with missing lock
• Assuming cache size grows without lock

4. A system uses early expiration to prevent cache stampede by setting cache TTL shorter than data TTL. However, users report stale data sometimes. What is the likely cause?

medium

A. Cache TTL is longer than data TTL causing stale reads

B. Cache is not refreshed after early expiration due to missing lock

C. Database is down causing stale cache

D. Cache size is too small causing evictions

Solution

1. Step 1: Understand early expiration technique

   Early expiration refreshes cache before data TTL ends to avoid stampede.

2. Step 2: Identify cause of stale data

   If cache refresh is not coordinated (missing lock), cache may not update properly, causing stale data.

3. Final Answer:

   Cache is not refreshed after early expiration due to missing lock -> Option B

4. Quick Check:

   Missing lock = stale cache after early expiration [OK]

Hint: Check if locking coordinates cache refresh [OK]

Common Mistakes:

• Assuming TTL mismatch causes stale data
• Blaming database downtime without evidence
• Confusing cache size with freshness

5. You design a high-traffic API with cache stampede prevention. Which combination best prevents stampede while ensuring fresh data and minimal DB load?

hard

A. Disable cache and use database connection pooling

B. Use long cache TTL with no locking and rely on DB scaling

C. Use short cache TTL with distributed locking and request coalescing

D. Use infinite cache TTL and manual cache invalidation

Solution

1. Step 1: Evaluate each option for stampede prevention

   Use long cache TTL with no locking and rely on DB scaling risks DB overload without locking; C disables cache increasing DB load; D risks stale data.

2. Step 2: Identify best practice combination

   Short TTL triggers refresh often; distributed locking prevents multiple refreshes; request coalescing merges requests to reduce DB hits.

3. Final Answer:

   Use short cache TTL with distributed locking and request coalescing -> Option C

4. Quick Check:

   Locking + coalescing + short TTL = best stampede prevention [OK]

Hint: Combine locking and coalescing with short TTL for best results [OK]

Common Mistakes:

• Ignoring locking and causing DB overload
• Disabling cache increases latency and load
• Using infinite TTL causes stale data