Response caching strategies in Flask - Step-by-Step Execution

Concept Flow - Response caching strategies

Client sends request

↓

Check cache for response

↓

Return cached

↓

response

↓

Store response in cache

↓

Return response to client

The flow shows how a Flask app checks for a cached response before generating a new one, improving speed by returning cached data when available.

Execution Sample

Flask

from flask import Flask, make_response
from flask_caching import Cache

app = Flask(__name__)
cache = Cache(app, config={'CACHE_TYPE': 'SimpleCache'})

@app.route('/')
@cache.cached(timeout=10)
def index():
    return 'Hello, cached world!'

This Flask code caches the response of the '/' route for 10 seconds to speed up repeated requests.

Execution Table

Step	Action	Cache State	Response Returned	Notes
1	Client requests '/'	Empty	No cached response	Cache miss, generate response
2	Generate response 'Hello, cached world!'	Empty	No response yet	Preparing response
3	Store response in cache with 10s timeout	Cache has '/' response	No response yet	Cache updated
4	Return response to client	Cache has '/' response	'Hello, cached world!'	Response sent
5	Client requests '/' again within 10s	Cache has '/' response	'Hello, cached world!'	Cache hit, fast return
6	Client requests '/' after 10s timeout	Cache expired	No cached response	Cache miss, regenerate response

💡 Execution stops when response is returned to client or cache expires causing regeneration.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6
cache['/']	None	'Hello, cached world!'	'Hello, cached world!'	None (expired)
response	None	'Hello, cached world!'	'Hello, cached world!'	'Hello, cached world!'

Key Moments - 2 Insights

Why does the cache return a response immediately on the second request?

Because at step 3 the response was stored in the cache, so at step 5 the cache has the response ready and returns it without regenerating.

What happens when the cache timeout expires?

At step 6, the cached response is expired (None), so the app must generate a new response and store it again.

Visual Quiz - 3 Questions

Look at the execution table, what is the cache state at step 2?

A Empty

B Cache has '/' response

C Cache expired

D No cache used

💡 Hint

Check the 'Cache State' column at step 2 in the execution table.

At which step does the cache store the response?

A Step 1

B Step 5

C Step 3

D Step 6

💡 Hint

Look for the step where 'Store response in cache' happens in the 'Action' column.

If the cache timeout was increased, how would step 6 change?

A Cache would still be expired at step 6

B Cache would have the response, so step 6 would be a cache hit

C Response would never be cached

D Step 6 would not occur

💡 Hint

Refer to the 'Cache State' and 'Notes' columns at step 6 and think about timeout effect.

Concept Snapshot

Response caching in Flask:
- Use @cache.cached(timeout=seconds) decorator
- On request, check cache first
- If cached, return cached response immediately
- If not, generate response and store in cache
- Cache expires after timeout, triggers regeneration
- Speeds up repeated requests by avoiding work

Full Transcript

This visual trace shows how Flask response caching works step-by-step. When a client requests a route, Flask first checks if a cached response exists. If not, it generates the response and stores it in cache with a timeout. Subsequent requests within the timeout get the cached response instantly. When the timeout expires, the cache is empty again, so Flask regenerates the response. This process improves performance by reducing repeated work. Variables like cache content and response change over time as shown. Key moments include understanding cache hits and expiration. The quiz tests understanding of cache state and timing.