Cache-Aside, Read-Through and Write Patterns

Cache-aside (lazy loading): the app reads the cache, loads from the database on a miss and populates the cache — the most common pattern. Read-through: the cache loads data itself via a loader. Write-through: writes update the cache and database together (fresh reads, slower writes). Write-behind: writes go to the cache and are flushed later (fast, but risk of loss). Write-around: writes skip the cache; it fills on read.

def get_product(id):
    key = f"product:v2:{id}"
    if (cached := redis.get(key)) is not None:
        return json.loads(cached)                 # hit
    product = db.fetch_product(id)                # miss → source of truth
    redis.set(key, json.dumps(product), ex=300 + random.randint(0, 30))   # TTL + jitter
    return product

def update_product(id, data):
    db.update_product(id, data)                   # 1. write the database (commit)
    redis.delete(f"product:v2:{id}")              # 2. invalidate (don't update) the cache

Common pitfalls

• Updating the cache instead of deleting it (race conditions leave stale values).
• Write-behind for data you can't afford to lose.
• No TTL as a safety net.

Key points

• Cache-aside is the default
• Delete on write, after commit
• TTL + jitter always

Further reading: AWS: Caching patterns