⚡ Caching Strategies

Speed up your app using smart caching techniques and background processing.

🧠 What is Caching?

Caching means storing data temporarily so that it can be fetched faster next time.

When your app repeatedly fetches data from a database or API, caching helps reduce the waiting time by keeping a copy of that data in memory (like Redis or browser cache).

💡 Real-World Example:
Think of caching like remembering your friend’s phone number. The first time you look it up, it takes time. The next time, you recall it instantly from memory.

🧩 1. Cache-Aside vs Write-Through Patterns

🔸 Cache-Aside Pattern (Lazy Loading)

How it works:

1. App checks the cache first.
2. If data is not found (cache miss), it fetches from the database.
3. It then stores the result in the cache for next time.

Simple Code Example (Python + Redis):

import redis

cache = redis.Redis()
def get_user(user_id):
    cached_user = cache.get(f"user:{user_id}")
    if cached_user:
        return cached_user
    user = db.query(User).filter(User.id == user_id).first()
    cache.set(f"user:{user_id}", user.name)
    return user.name

💡 Real-World Example: E-commerce sites like Amazon use cache-aside for product details. When a user views a product, it’s stored in cache so the next visitor sees it instantly.

🔹 Write-Through Pattern

How it works:

1. Every time data is written to the database, it is also written to the cache at the same time.
2. Reads are always served from the cache.

Simple Code Example:

def update_user_name(user_id, new_name):
    db.query(User).filter(User.id == user_id).update({"name": new_name})
    db.commit()
    cache.set(f"user:{user_id}", new_name)

💡 Real-World Example: Banking systems use write-through caching so that both cache and database are always in sync — avoiding stale or old data when showing account balances.

⚖️ Difference

🧱 2. Redis Data Structures and Use Cases

Redis isn’t just a simple cache — it’s a powerful in-memory data store with different structures for different problems.

🔸 1. Strings

Used for storing simple key-value data.

Example:

cache.set("user:1:name", "Safi")
print(cache.get("user:1:name"))

💡 Use Case: Store temporary tokens, session IDs, or user details. Example: Authentication systems storing short-lived login tokens.

🔸 2. Lists

Used for storing ordered data (like queues).

Example:

cache.lpush("tasks", "send_email")
cache.lpush("tasks", "generate_report")

💡 Use Case: Used for background jobs or task queues — like sending emails one after another.

🔸 3. Hashes

Used for storing objects (like a user profile).

Example:

cache.hset("user:1", mapping={"name": "Safi", "role": "Admin"})
print(cache.hgetall("user:1"))

💡 Use Case: Store structured data like user settings or shopping cart details.

🔸 4. Sets

Used for unique items (no duplicates).

Example:

cache.sadd("online_users", "user1")
cache.sadd("online_users", "user2")

💡 Use Case: Tracking active users or unique visitors on a website.

🔸 5. Sorted Sets

Used for ranking data by score.

Example:

cache.zadd("leaderboard", {"Safi": 100, "Zoya": 120})

💡 Use Case: Used for leaderboards, trending posts, or most-viewed products.

🌐 3. HTTP Caching Headers

Web browsers and servers use HTTP headers to cache responses and reduce load.

🔸 Common Headers

✅ Example (FastAPI)

from fastapi import FastAPI, Response

app = FastAPI()

@app.get("/products")
def get_products():
    response = Response(content="Product data")
    response.headers["Cache-Control"] = "max-age=3600"
    response.headers["ETag"] = "v1"
    return response

💡 Real-World Example: News websites use HTTP caching so that static content like CSS, JS, and images load instantly from the browser cache instead of downloading again every time.

⚙️ 4. Database Query Optimization

Sometimes caching alone isn’t enough — we also need to make queries efficient.

🔸 1. Use Indexes

Indexes help the database find data faster.

Example (SQL):

CREATE INDEX idx_user_name ON users (name);

💡 Real-World Example: A large user database like Instagram’s uses indexes on username and email columns to quickly find profiles.

🔸 2. Limit Results

Only fetch the data you need.

Example (SQL):

SELECT * FROM products LIMIT 10 OFFSET 0;

💡 Real-World Example: Pagination on e-commerce sites — loading only a few items per page instead of the whole catalog.

🔸 3. Avoid N+1 Queries

Instead of fetching related data in a loop, use joins or prefetching.

Example (SQLAlchemy):

users = db.query(User).options(joinedload(User.posts)).all()

💡 Real-World Example: Social apps like Twitter use preloading to fetch user info and tweets together, reducing round trips.

⏳ 5. Background Task Processing

Some tasks don’t need to run immediately — they can run in the background to improve performance.

🔸 Example Using Celery with Redis

from celery import Celery

app = Celery("tasks", broker="redis://localhost:6379")

@app.task
def send_email(to, subject):
    print(f"Sending email to {to}: {subject}")

Now you can queue a task:

send_email.delay("user@example.com", "Welcome!")

💡 Real-World Example: Email confirmation, image compression, or report generation are run in the background so users don’t have to wait.

🧾 Summary

💡 Final Thought

Caching is about speed + efficiency. When used correctly, it can reduce your app’s load time from seconds to milliseconds.

Companies like Netflix, Amazon, and Instagram heavily depend on caching to serve millions of users quickly. The key is to choose the right caching pattern and refresh strategy for your use case.