How much Redis do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can use Redis as a cache.”
Start with what Redis actually is and its core data types, then the cache-aside pattern — the 80% use case.
- You've seen Redis mentioned in a docker-compose file without knowing what it did
- You haven't written to or read from Redis yourself
- You want the core data types and caching once, in order
“I can use Redis for more than caching.”
You can cache with Redis. Now learn pub/sub, sessions, rate limiting, queues, and the persistence/transaction model underneath it all.
- Comfortable with the core data types and basic caching
- You've reached for a heavier tool when Redis pub/sub would've done the job
- You want Redis as a session store, rate limiter and lightweight queue
“I can run Redis in production.”
Clustering, high availability, and the performance tuning behind a Redis deployment that's more than a single-instance cache.
- You can already build rate limiters and pub/sub features in Redis
- You debug memory pressure and eviction surprises, not just cache misses
- You want the why under clustering, Sentinel and eviction policies
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 6 sections written
- What Redis iscoming soon
An in-memory data store, and why that makes it fast
- Basic data typescoming soon
Strings, hashes, lists, sets, sorted sets
- Setting up & connectingcoming soon
redis-cli, a client library
- Expiration & TTLscoming soon
How keys expire, and why that matters
- Redis as a cachecoming soon
The cache-aside pattern
- A caching example end to endcoming soon
Putting the basic commands into a real flow
✅ Checkpoint: you can add a Redis cache in front of a slow query, with correct TTLs and invalidation, and explain why it's faster.
Intermediate0 / 8 sections written
- Pub/Subcoming soon
Real-time messaging with Redis
- Redis as a session storecoming soon
Storing and expiring sessions
- Rate limiting with Rediscoming soon
Sliding window, token bucket
- Redis for queuescoming soon
Simple job queues, and where BullMQ fits
- Persistencecoming soon
RDB vs AOF, when it actually matters
- Data structures in depthcoming soon
Sorted sets for leaderboards, HyperLogLog
- Transactions in Rediscoming soon
MULTI/EXEC, optimistic locking with WATCH
- Connecting Redis to a real appcoming soon
Connection pooling, error handling
✅ Checkpoint: you can build a sliding-window rate limiter and a real-time pub/sub feature in Redis, and explain RDB vs AOF tradeoffs.
Advanced0 / 7 sections written
- Redis Clustercoming soon
Sharding and replication
- High availabilitycoming soon
Sentinel, failover
- Performance tuningcoming soon
Memory management, eviction policies
- Redis as a primary datastorecoming soon
When it's more than a cache
- Redis Streamscoming soon
Event-sourcing-style patterns
- Securitycoming soon
ACLs, TLS, avoiding exposed instances
- Scaling Redis in productioncoming soon
Real-world case-study thinking
✅ Checkpoint: you can design a highly-available Redis deployment (Cluster + Sentinel), tune eviction policy for a memory-constrained workload, and defend using Redis as more than a cache.
- Redis's data types get a whole beginner chapter to themselves — hashes, sets and sorted sets solve real problems (leaderboards, dedup, tagging) that a plain key-value cache can't.
- Rate limiting is intermediate, not advanced, because it's one of the most common reasons a working app reaches for Redis at all — it's not a niche use case.
- Redis as a primary datastore and Redis Streams are the deepest, least common layer — most Redis usage is "just a cache," but the advanced tier doesn't skip when it's more than that.