Free through lesson 3

Redis & NoSQL for Beginners

We start from the places where an RDB alone starts to hurt, then cover Redis's five types and TTL, measuring and invalidating a cache, sessions, rate limiting, and job queues, all the way to document design in MongoDB. Over 30 lessons, you'll get to the point where you can decide for yourself "where should this data live?" Every command output and timing in this course was measured by actually running Redis 8.10.2 and MongoDB 8.0.4.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into 6 chapters. We recommend going in order from chapter 1, but feel free to jump to whatever interests you. Note: redis-cli and mongosh can't run in the browser. Install Redis and MongoDB on your own machine to try things out (setup steps are in lesson 2 and lesson 25).

Chapter 1 — Where an RDB Alone Falls Short (lessons 1–4)

We measure exactly where the relational database you use today starts to struggle. At the end, we draw a map of what's called NoSQL, then start Redis and try it out.

When an RDB Alone Isn't Enough

Aggregating 200,000 rows takes 137.8 ms. Run the same query 20 times and it's 2757 ms. The RDB isn't slow; the problem is rebuilding the same answer again and again.

Free

Starting Redis and Trying It Out

From brew install redis to a PING in redis-cli. Try SET and GET, and reproduce a measured 90,000+ operations per second on your own machine.

Free

Data You Can Lose, and Data You Can't

Stop cleaning up expired sessions with DELETE forever. Attach a TTL and you need zero lines of cleanup code. But everything vanishes on restart.

Free

Shapeless Data, and a Map of NoSQL

The limits of adding columns that only 1 in 1000 rows uses. JSON columns as an escape hatch, and a map of the four kinds of NoSQL.

Chapter 2 — Redis Types (lessons 5–12)

Get hands-on with all five types (strings, hashes, lists, sets, and sorted sets) plus TTL, which you can attach to any of them. At the end, you'll use pipelines and MULTI to cut down the number of round trips themselves.

Designing Keys, and Why You Shouldn't Use KEYS

Build namespaces with colon-separated names. Run KEYS in production and everyone has to wait. Use SCAN instead.

Strings, and Counting

Redis strings also behave as numbers. INCR reads, adds, and writes in a single command, so there are no races.

Grouping One Thing Together with Hashes

Don't make user:1:name and user:1:email separate keys. A hash lets you read and write field by field, and delete it as one unit.

Keeping Order with Lists

A queue you can push to and pop from at both ends. RPUSH in and LPOP out gives you first-in, first-out. LTRIM keeps the length in check.

No Duplicates with Sets

Each value goes in only once. Membership checks take one command, and Redis can compute intersections, unions, and differences for you.

Keeping Rank with Sorted Sets

Give each value a score and Redis keeps them sorted at all times. Fetching a leaderboard or a rank is a single command.

TTL and Expiration

Set a lifetime with EXPIRE. TTL return values -1 and -2 mean different things. The biggest pitfall: overwriting a key erases its lifetime.

Pipelines and MULTI

Pipelines cut the number of round trips themselves. MULTI prevents interleaving, but it doesn't roll back if something fails midway.

Chapter 3 — Caching (lessons 13–18)

Build the cache-aside pattern, then learn how to choose a TTL and run into the pitfalls of invalidation. You'll measure hit rates and timings for real, and also deal with stampedes and memory limits.

The Basic Cache Pattern (Cache-Aside)

Check Redis first; if it's not there, read from the DB and put it in Redis. The one move that turns 137.8 ms into 0.20 ms.

What to Cache, and What TTL to Use

Don't cache everything. Only things that are read often, expensive to build, and fine to be a little stale. Pick the TTL by how much staleness you can tolerate.

You Updated It, but the Old Value Comes Back

Rewrite the DB and the cache stays stale. Watch it keep returning JP, then add a DEL.

Measuring the Effect: Hit Rate and Timing

Don't stop at adding a cache. Compute the hit rate from keyspace_hits and keyspace_misses, and find the caches that aren't helping.

Cache Stampedes

The moment a TTL expires, 20 simultaneous requests all rush to the DB. A SET NX lock lets only one through.

Memory Limits and Eviction

If you don't set maxmemory, you'll eventually use it all. Measure how inserting 10,000 entries leaves only 1546.

Chapter 4 — Sessions, Rate Limiting, and Queues (lessons 19–24)

Build login-state storage, rate limiting with counters, and job handoff with lists. At the end, we tackle the problems every queue runs into: double execution and lost jobs.

Storing Sessions in Redis

Keep login state in a hash plus a TTL. No more cleanup cron, and logins survive when you add more servers.

Using It from a Framework

Change one setting in Django, Rails, or Express and your sessions move to Redis. Check for an off-the-shelf solution before building your own.

Rate Limiting: INCR and Fixed Windows

Count with INCR and add EXPIRE only on the first hit. When the window ends, the counter disappears with it, so no reset logic is needed.

The Hole in Fixed Windows, and Sliding Windows

Straddle a window boundary and a limit of 5 lets 10 through in a short time. Use a sorted set to count "the last N seconds" correctly.

Job Queues: Handing Off with Lists

Push with RPUSH and wait with BLPOP. Stop polling and you cut both CPU use and wait time. In our measurement it blocked for 2.19 seconds.

Double Execution and Lost Jobs

Crash right after LPOP and the job is gone. Move it to an in-progress list with LMOVE, and make work idempotent to survive double execution.

Chapter 5 — MongoDB (lessons 25–28)

We check document-oriented data design by actually starting mongod. After looking at queries, indexes, and explain, we compare it with JSON columns in an RDB and sort out how to choose.

MongoDB and Document Orientation

Insert data without creating tables or schemas. Keep attributes that differ from product to product in their natural shape.

Queries, Updates, and Aggregation

Condition operators in find, partial updates with $set and $push, and the GROUP BY equivalent with aggregate. Read them side by side with SQL.

Indexes and explain

A COLLSCAN over 200,000 documents takes 47 ms. Add one index and the documents examined drop from 200000 to 5.

How It Differs from an RDB, and When JSON Columns Are Enough

Embed or reference? Limits on joins and transactions. And the option of "not adding MongoDB at all."

Chapter 6 — Choosing (lessons 29–30)

We measure when data disappears on restart and how RDB and AOF differ. Finally, we turn it all into a step-by-step way to decide where the data in front of you should live.

Persistence, and What You Lose When Things Fail

With save '' everything vanishes on restart. See how RDB snapshots and AOF differ by actually wiping data.

Deciding Where Data Lives

A wrap-up of all 30 lessons. A step-by-step way to choose where data lives from its nature, and when you're better off not adding anything.

Once you've finished all 30 lessons, shore up the RDB side with Database Fundamentals with PostgreSQL, or learn to watch whether your cache is really working in production with Monitoring & Observability for Beginners. A membership unlocks every course.