Cache invalidation strategies in Rest API - Mini Project: Build & Apply

Cache Invalidation Strategies in REST API

📖 Scenario: You are building a simple REST API for a bookstore. To make the API faster, you want to add caching for book details. But when book information changes, the cache must be updated or cleared so users get fresh data.

🎯 Goal: Build a small REST API simulation that stores book data, caches book details, and uses a cache invalidation strategy to update the cache when book data changes.

📋 What You'll Learn

Create a dictionary called books with 3 books and their prices

Create a cache dictionary called cache to store cached book details

Write a function get_book_details(book_id) that returns cached data if available, otherwise fetches from books and caches it

Write a function update_book_price(book_id, new_price) that updates the book price and invalidates the cache for that book

Print the cached data before and after updating a book price to show cache invalidation

💡 Why This Matters

🌍 Real World

Caching is used in real REST APIs to speed up responses by storing data temporarily. Cache invalidation ensures users get fresh data when updates happen.

💼 Career

Understanding cache invalidation is important for backend developers working with APIs, improving performance and data accuracy.

1

Create the initial book data

Create a dictionary called books with these exact entries: 1: {'title': 'Python Basics', 'price': 29.99}, 2: {'title': 'REST APIs', 'price': 39.99}, 3: {'title': 'Data Science', 'price': 49.99}

Rest API

# Create the books dictionary with 3 books
# Your code here

Hint

Use a dictionary with keys 1, 2, 3 and values as dictionaries with keys 'title' and 'price'.

2

Create the cache dictionary

Create an empty dictionary called cache to store cached book details

Rest API

books = {
    1: {'title': 'Python Basics', 'price': 29.99},
    2: {'title': 'REST APIs', 'price': 39.99},
    3: {'title': 'Data Science', 'price': 49.99}
}
# Create an empty cache dictionary
# Your code here

Hint

Just create an empty dictionary named cache.

3

Write functions for caching and invalidation

Write a function called get_book_details(book_id) that returns cached data if book_id is in cache. Otherwise, fetch the book from books, store it in cache, and return it. Also write a function called update_book_price(book_id, new_price) that updates the price in books and removes the book_id from cache to invalidate it.

Rest API

books = {
    1: {'title': 'Python Basics', 'price': 29.99},
    2: {'title': 'REST APIs', 'price': 39.99},
    3: {'title': 'Data Science', 'price': 49.99}
}

cache = {}

# Write get_book_details(book_id) function
# Write update_book_price(book_id, new_price) function
# Your code here

Hint

Use if book_id in cache to check cache. Use del cache[book_id] to invalidate cache.

4

Print cache before and after update

Print the result of get_book_details(2) to show cached data. Then call update_book_price(2, 44.99) to update the price and invalidate the cache. Finally, print get_book_details(2) again to show updated data is fetched and cached.

Rest API

books = {
    1: {'title': 'Python Basics', 'price': 29.99},
    2: {'title': 'REST APIs', 'price': 39.99},
    3: {'title': 'Data Science', 'price': 49.99}
}

cache = {}

def get_book_details(book_id):
    if book_id in cache:
        return cache[book_id]
    else:
        book = books.get(book_id)
        if book:
            cache[book_id] = book
        return book

def update_book_price(book_id, new_price):
    if book_id in books:
        books[book_id]['price'] = new_price
        if book_id in cache:
            del cache[book_id]

# Print cached data before update
# Update price and invalidate cache
# Print cached data after update
# Your code here

Hint

Print the result of get_book_details(2), then call update_book_price(2, 44.99), then print get_book_details(2) again.

Practice

1. Which cache invalidation strategy automatically removes cached data after a set period of time?

easy

A. Manual invalidation

B. Event-based invalidation

C. Time-based invalidation

D. Versioning invalidation

Solution

1. Step 1: Understand time-based invalidation

   Time-based invalidation removes cached data after a fixed time, ensuring data freshness automatically.

2. Step 2: Compare with other strategies

   Manual invalidation requires user action, event-based depends on data changes, and versioning uses data versions.

3. Final Answer:

   Time-based invalidation -> Option C

4. Quick Check:

   Automatic removal after time = Time-based invalidation [OK]

Hint: Time-based means cache expires after set time [OK]

Common Mistakes:

• Confusing manual with automatic removal
• Thinking event-based triggers on time
• Mixing versioning with time expiry

2. Which of the following is the correct way to manually invalidate a cache entry in a REST API?

easy

A. Send a PUT request to update cached data

B. Send a GET request to the cache endpoint

C. Send a POST request to retrieve cached data

D. Send a DELETE request to the cache endpoint

Solution

1. Step 1: Identify HTTP method for deletion

   DELETE requests are used to remove resources, including cache entries.

2. Step 2: Understand other methods

   GET retrieves data, POST creates, and PUT updates; none remove cache.

3. Final Answer:

   Send a DELETE request to the cache endpoint -> Option D

4. Quick Check:

   DELETE removes cache entry manually [OK]

Hint: DELETE method removes resources like cache entries [OK]

Common Mistakes:

• Using GET to remove cache
• Confusing POST with deletion
• Thinking PUT deletes cache

3. Consider this pseudo-code for event-based cache invalidation:

if (dataChangedEvent) {
  invalidateCache(key);
}
return getCachedData(key);

What will happen if dataChangedEvent is true?

medium

A. Cache is invalidated and fresh data is fetched next time

B. Cache remains unchanged and stale data is returned

C. Cache is updated without invalidation

D. An error occurs because cache cannot be invalidated

Solution

1. Step 1: Analyze the condition

   If dataChangedEvent is true, invalidateCache(key) runs, removing cached data.

2. Step 2: Understand cache behavior after invalidation

   After invalidation, next data fetch will get fresh data, not stale cache.

3. Final Answer:

   Cache is invalidated and fresh data is fetched next time -> Option A

4. Quick Check:

   Event triggers invalidation = fresh data next fetch [OK]

Hint: Event true means cache cleared for fresh data [OK]

Common Mistakes:

• Assuming cache stays after invalidation
• Thinking cache updates automatically
• Believing invalidation causes errors

4. You have this code snippet for versioning cache invalidation:

cache = { 'v1': data1 }
function getData(version) {
  return cache[version];
}

// Later
cache['v2'] = newData;

What is the main bug if the client still requests v1 after update?

medium

A. Cache throws an error because version key is missing

B. Client gets stale data because old version is still cached

C. Cache automatically updates old version to new data

D. Client cannot access any cached data

Solution

1. Step 1: Understand versioning cache behavior

   Old version 'v1' remains in cache, so requests for it get stale data.

2. Step 2: Identify bug impact

   Client requesting 'v1' does not see 'v2' data, causing stale responses.

3. Final Answer:

   Client gets stale data because old version is still cached -> Option B

4. Quick Check:

   Old version key returns stale data [OK]

Hint: Old version keys keep stale data unless removed [OK]

Common Mistakes:

• Assuming cache auto-updates old versions
• Expecting errors on missing keys
• Thinking client loses all cache access

5. You want to design a cache invalidation strategy for a REST API where data changes frequently but must stay fresh within 5 minutes. Which combined strategy is best?

hard

A. Use time-based invalidation with 5-minute expiry plus event-based invalidation on data changes

B. Use manual invalidation only, requiring user to clear cache

C. Use versioning only without time limits

D. Use time-based invalidation with 1-hour expiry only

Solution

1. Step 1: Analyze freshness requirement

   Data must be fresh within 5 minutes, so time-based expiry should be 5 minutes or less.

2. Step 2: Combine with event-based invalidation

   Event-based invalidation clears cache immediately on data changes, improving freshness.

3. Step 3: Evaluate other options

   Manual invalidation is slow, versioning alone may keep stale data, and 1-hour expiry is too long.

4. Final Answer:

   Use time-based invalidation with 5-minute expiry plus event-based invalidation on data changes -> Option A

5. Quick Check:

   Combine time and event for fresh cache [OK]

Hint: Combine time and event for best freshness [OK]

Common Mistakes:

• Relying only on manual invalidation
• Using too long expiry times
• Ignoring event triggers for changes