Redis beyond caching: 5 use cases you should know

#redis #backend #database #systemdesign

Most developers know Redis as a cache. But it's capable of much more. Here are 5 patterns I use in production.

1. Rate Limiting

import redis

r = redis.Redis()

def is_rate_limited(user_id, limit=100, window=60):
    key = f"rate:{user_id}"
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current > limit

Simple, atomic, and fast. No database queries needed.

2. Distributed Locks

When multiple workers might process the same job:

import redis

r = redis.Redis()

def acquire_lock(name, timeout=10):
    return r.set(f"lock:{name}", "1", nx=True, ex=timeout)

def release_lock(name):
    r.delete(f"lock:{name}")

# Usage
if acquire_lock("process-order-123"):
    try:
        process_order(123)
    finally:
        release_lock("process-order-123")

nx=True means "set only if not exists" — atomic mutex.

3. Real-time Leaderboard

# Add scores
r.zadd("leaderboard", {"player_a": 1500, "player_b": 2100, "player_c": 1800})

# Top 10 players
top_10 = r.zrevrange("leaderboard", 0, 9, withscores=True)

# Player rank
rank = r.zrevrank("leaderboard", "player_a")  # 0-indexed

# Update score atomically
r.zincrby("leaderboard", 50, "player_a")

Sorted sets handle millions of entries with O(log N) operations.

4. Pub/Sub for Real-time Events

# Publisher
r.publish("notifications", json.dumps({
    "user_id": 123,
    "message": "New order received"
}))

# Subscriber
pubsub = r.pubsub()
pubsub.subscribe("notifications")

for message in pubsub.listen():
    if message["type"] == "message":
        data = json.loads(message["data"])
        send_push_notification(data)

Lightweight alternative to Kafka/RabbitMQ for simple event streaming.

5. Session Storage

from flask import Flask, session
from flask_session import Session

app = Flask(__name__)
app.config["SESSION_TYPE"] = "redis"
app.config["SESSION_REDIS"] = redis.Redis(host="localhost")
Session(app)

@app.route("/login")
def login():
    session["user_id"] = 123  # Stored in Redis, not cookies

Advantages over cookie-based sessions:

Server-side: can't be tampered with
Shared across instances (horizontal scaling)
Easy to invalidate: just delete the key

When NOT to use Redis

Primary database: Redis is in-memory, data loss risk on crash (even with AOF)
Large objects: Keep values under 1MB
Complex queries: No SQL, limited filtering

What's your favorite Redis use case? I'm curious what patterns work for others.

DEV Community