Cache-aside pattern in HLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to describe the first step in the cache-aside pattern.

HLD

When a request comes in, the system first checks the [1] for the data.

Drag options to blanks, or click blank then click option'

Adatabase

Bnetwork

Ccache

Dfilesystem

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing cache with database as the first data source.

Assuming data is fetched directly from the network.

The cache-aside pattern starts by checking the cache for data before querying the database.

2fill in blank

medium

Complete the code to describe what happens if data is not found in the cache.

HLD

If the data is not in the cache, the system fetches it from the [1].

Drag options to blanks, or click blank then click option'

Aclient

Bdatabase

Ccache

DAPI gateway

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to fetch data again from the cache.

Assuming data comes from the client or API gateway.

When cache misses occur, the system retrieves data from the database.

3fill in blank

hard

Fix the error in the description of updating the cache after fetching data.

HLD

After fetching data from the database, the system [1] the cache with the new data.

Drag options to blanks, or click blank then click option'

Aupdates

Bdeletes

Cignores

Dinvalidates

Attempts:

3 left

💡 Hint

Common Mistakes

Thinking the cache should be invalidated or deleted after fetching data.

Ignoring the cache update step.

The cache-aside pattern updates the cache with fresh data after a database fetch to speed up future requests.

4fill in blank

hard

Fill both blanks to complete the cache-aside pattern steps for a write operation.

HLD

When data is updated, the system writes to the [1] first, then [2] the cache to keep it consistent.

Drag options to blanks, or click blank then click option'

Adatabase

Breads

Cinvalidates

Dwrites

Attempts:

3 left

💡 Hint

Common Mistakes

Writing to the cache before the database.

Not invalidating the cache after a write.

In cache-aside, writes go to the database first, then the cache is invalidated to avoid stale data.

5fill in blank

hard

Fill all three blanks to complete the cache-aside pattern read flow with cache miss handling.

HLD

On a cache miss, the system fetches data from the [1], then [2] the cache, and finally [3] the data to the client.

Drag options to blanks, or click blank then click option'

Adatabase

Bupdates

Creturns

Dinvalidates

Attempts:

3 left

💡 Hint

Common Mistakes

Invalidating the cache instead of updating it on a cache miss.

Returning data before updating the cache.

The system fetches from the database, updates the cache, and returns data to the client in the cache-aside pattern.

Practice

1. What is the main purpose of the cache-aside pattern in system design?

easy

A. To load data into cache only when it is requested

B. To preload all data into cache before any request

C. To write data directly to cache without database interaction

D. To keep cache and database completely separate without synchronization

Solution

1. Step 1: Understand cache-aside pattern behavior

   The cache-aside pattern loads data into cache only when the application requests it and the data is not already cached.

2. Step 2: Compare options with this behavior

   To load data into cache only when it is requested correctly states this lazy loading approach. Other options describe preloading or unsynchronized caching, which are incorrect.

3. Final Answer:

   To load data into cache only when it is requested -> Option A

4. Quick Check:

   Cache-aside = lazy loading on demand [OK]

Hint: Cache-aside loads data only when requested [OK]

Common Mistakes:

• Thinking cache preloads all data
• Assuming cache updates happen before DB writes
• Believing cache and DB are unsynchronized

2. Which of the following is the correct sequence of operations in the cache-aside pattern when reading data?

easy

A. Read from database -> Update cache -> Return data

B. Read from cache -> If miss, read from database -> Update cache

C. Update cache -> Read from cache -> Read from database

D. Read from cache -> Return data without checking database

Solution

1. Step 1: Recall cache-aside read flow

   When reading, the system first checks the cache. If data is missing (cache miss), it reads from the database and then updates the cache.

2. Step 2: Match this flow to options

   Read from cache -> If miss, read from database -> Update cache matches this exact sequence. Other options either skip cache miss handling or update cache before reading.

3. Final Answer:

   Read from cache -> If miss, read from database -> Update cache -> Option B

4. Quick Check:

   Cache read -> DB read on miss -> Cache update [OK]

Hint: Cache read first, DB read only if cache miss [OK]

Common Mistakes:

• Updating cache before reading database
• Ignoring cache miss and reading only cache
• Reading database before checking cache

3. Consider this pseudocode using cache-aside pattern:

function getUser(id) {
  user = cache.get(id)
  if (user == null) {
    user = database.query(id)
    cache.set(id, user)
  }
  return user
}

What will getUser(5) return if the cache is empty and the database has user with id 5?

medium

A. null

B. Error due to cache miss

C. Empty object

D. User data from database

Solution

1. Step 1: Analyze cache miss handling

   Since cache is empty, cache.get(5) returns null, triggering database query.

2. Step 2: Database query and cache update

   The function queries the database for user id 5, finds the user data, updates the cache, and returns the user data.

3. Final Answer:

   User data from database -> Option D

4. Quick Check:

   Cache miss triggers DB read and cache update [OK]

Hint: Cache miss leads to DB read and cache update [OK]

Common Mistakes:

• Assuming cache miss returns null directly
• Expecting error on cache miss
• Ignoring cache update after DB read

4. A developer implemented cache-aside but notices stale data in cache after database updates. What is the likely mistake?

medium

A. Not updating cache after database write

B. Reading from cache before database

C. Preloading cache with all data

D. Using cache for write operations only

Solution

1. Step 1: Identify cause of stale cache

   Stale cache means cache has old data not reflecting recent database updates.

2. Step 2: Check cache update after DB write

   If cache is not updated or invalidated after database writes, stale data remains in cache.

3. Final Answer:

   Not updating cache after database write -> Option A

4. Quick Check:

   Cache must update after DB write to avoid stale data [OK]

Hint: Always update cache after DB write to avoid stale data [OK]

Common Mistakes:

• Ignoring cache invalidation after writes
• Assuming cache updates automatically
• Confusing read and write cache operations

5. You design a high-traffic product catalog service using cache-aside pattern. To handle frequent updates and reads, which strategy best maintains cache consistency and performance?

hard

A. Preload entire product catalog into cache at service start and never update cache

B. On product update, write to DB only and let cache expire naturally

C. On product update, write to DB then immediately update cache with new data

D. Write updates only to cache and asynchronously sync to DB later

Solution

1. Step 1: Understand cache consistency needs

   For frequent updates and reads, cache must reflect latest data quickly to avoid stale reads.

2. Step 2: Evaluate update strategies

   On product update, write to DB then immediately update cache with new data updates DB then cache immediately, ensuring cache consistency and fast reads. On product update, write to DB only and let cache expire naturally risks stale cache. Preload entire product catalog into cache at service start and never update cache ignores updates. Write updates only to cache and asynchronously sync to DB later risks data loss and inconsistency.

3. Final Answer:

   On product update, write to DB then immediately update cache with new data -> Option C

4. Quick Check:

   Update DB then cache for consistency and performance [OK]

Hint: Update DB then cache immediately for fresh data [OK]

Common Mistakes:

• Relying on cache expiration alone
• Preloading cache without updates
• Writing only to cache without DB sync