Caching strategies in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI endpoint with cache?

Consider this FastAPI endpoint using a simple in-memory cache dictionary. What will be the response when calling /data twice?

FastAPI

from fastapi import FastAPI
app = FastAPI()
cache = {}

@app.get('/data')
async def get_data():
    if 'value' in cache:
        return {'data': cache['value']}
    cache['value'] = 'cached result'
    return {'data': 'cached result'}

A 500 Internal Server Error on both calls

B {"data": "cached result"} on first call, then same on second call

C {"data": null} on first call, then {"data": "cached result"} on second call

D {"data": "cached result"} on first call, then KeyError on second call

💡 Hint

Think about how the cache dictionary stores and returns the value.

The cache dictionary stores the value after the first call. On the second call, it returns the cached value without error.

📝 Syntax

intermediate

Which option correctly uses FastAPI's Depends for caching?

FastAPI allows dependency injection for caching. Which code snippet correctly uses Depends to inject a cache dependency?

A

from fastapi import Depends
cache = {}
async def get_cache():
    return cache

@app.get('/item')
async def read_item(cache=Depends(get_cache)):
    return {'cache_size': len(cache)}

B

from fastapi import Depends
cache = {}
async def get_cache():
    return cache

@app.get('/item')
async def read_item(cache=get_cache()):
    return {'cache_size': len(cache)}

C

from fastapi import Depends
cache = {}
async def get_cache():
    return cache

@app.get('/item')
async def read_item(cache=Depends(get_cache())):
    return {'cache_size': len(cache)}

D

from fastapi import Depends
cache = {}
async def get_cache():
    return cache

@app.get('/item')
async def read_item(cache=Depends):
    return {'cache_size': len(cache)}

💡 Hint

Remember that Depends takes a callable without calling it.

Option A correctly passes the function get_cache to Depends without calling it. Other options either call the function or misuse Depends.

🔧 Debug

advanced

Why does this FastAPI cache implementation cause stale data?

Given this code snippet, why might the cache return outdated data?

FastAPI

from fastapi import FastAPI
app = FastAPI()
cache = {'data': 'old'}

@app.get('/update')
async def update_data():
    cache['data'] = 'new'
    return {'status': 'updated'}

@app.get('/data')
async def get_data():
    return {'data': cache['data']}

A Because the cache dictionary is global and shared, updates affect all requests immediately, so no stale data occurs

B Because the cache is not thread-safe, concurrent requests may see stale or inconsistent data

C Because the cache is updated only on /update, if /data is called before /update, it returns old data

D Because FastAPI automatically clears cache dictionaries after each request, causing stale data

💡 Hint

Think about when the cache value changes and when it is read.

The cache starts with 'old'. It only updates when /update is called. If /data is called before /update, it returns the old cached value, which may be stale.

🧠 Conceptual

advanced

Which caching strategy best fits FastAPI for data that changes every minute?

You have an API endpoint that returns data updated every minute. Which caching strategy is best to reduce load but keep data fresh?

A Use client-side caching only, relying on browser cache headers

B Use no caching to always return fresh data, ignoring performance

C Use a cache that never expires and manually clear it when data changes

D Use in-memory cache with a time-to-live (TTL) of 60 seconds to expire cached data automatically

💡 Hint

Think about balancing freshness and performance with automatic expiration.

Using a TTL cache with 60 seconds expiry keeps data fresh and reduces server load by caching responses for one minute.

❓ state_output

expert

What is the output after these FastAPI cache updates?

Given this FastAPI app, what is the output of calling /get after calling /set/5 and then /set/10?

FastAPI

from fastapi import FastAPI
app = FastAPI()
cache = {}

@app.get('/set/{value}')
async def set_value(value: int):
    cache['num'] = value
    return {'status': 'set', 'value': value}

@app.get('/get')
async def get_value():
    return {'num': cache.get('num', 0)}

A {"num": 10}

B {"num": 5}

C {"num": 0}

D KeyError exception

💡 Hint

Consider the order of calls and how the cache dictionary updates.

The cache key 'num' is first set to 5, then overwritten to 10. The /get endpoint returns the latest cached value 10.