Redis for Developers: Caching & Data Structures

It is built for students and freshers who can build a basic backend in any language and know what a database is, but have not used Redis. It also suits backend developers who already call Redis through a framework's cache helper without knowing what happens underneath, developers who need a leaderboard, a rate limiter or a job queue and want to pick the right data structure for it, and students who expect Redis questions in backend system design interviews. The course skips installation and GUI tools and goes straight to commands.

The course runs as 164 short lessons in 14 topics: foundations, keys and expiry, strings and hashes, lists, sets and sorted sets, compact counting, caching patterns, eviction and memory, application patterns, transactions and scripting, messaging, persistence and scale, modules and search, and security and interviews, followed by a final review topic. A lesson is a handful of reading cards with the commands for each step, diagrams where a picture explains more than a paragraph, and narration you can play while you read. Every lesson ends with a quiz, and each question shows an explanation after you answer, so a wrong pick turns into the rule you were missing. The course and each of its topics open with a short overview of what is coming.

There is no built-in terminal. To run what you learn, use any Redis 8 server you can reach, with redis-cli or a client library in your own language. If you want the relational side that Redis usually sits next to, MySQL Bootcamp: Beginner to Advanced covers it, and REST APIs with Flask builds a Python API with a database behind it, a natural place to try the caching patterns from this course.

Much of using Redis well is choosing between two options that both seem to work. The final topic sets the most commonly confused ones side by side:

• A hash vs a JSON document for storing an object
• Pub/sub vs streams for messages
• Expiry vs eviction
• A sorted set vs a list
• A set vs a bitmap for tracking members

It also practises choosing a cache pattern, an eviction policy, a data structure and a lock approach, and closes with practical cases: a session store at scale, a leaderboard service, a job queue built on streams, rate limits in an API and a feature flag cache. Along the way the course spends time on the pitfalls that catch developers out, such as running KEYS on a large database, keys that never expire, transactions that do not roll back, pub/sub messages lost when no one is subscribed, write-behind caches losing writes, and locks that expire while still in use.

Udemy and Coursera Redis courses are mostly video lectures in which an instructor types commands on screen. freeCodeCamp is the right choice if you want long video tutorials and written guides at no cost. This course does a different job: one idea per lesson, then questions on it straight away, so you find out whether you can predict what TTL returns after a SET, say which keys an eviction policy will remove, or tell whether a lock is safe to release. Watching someone run commands builds familiarity; answering questions about them shows what you can actually do.

Predict before you run. Before each command in a lesson, guess what Redis will reply, then check your guess against the cards and the quiz. Take a few lessons a day rather than one long weekly session, read every explanation, including the ones for answers you guessed, and after each topic try the commands yourself in redis-cli on a Redis 8 server. Once you reach the caching patterns, rebuild the lesson 1 cache in your own backend, give it an expiry and an invalidation rule, and check its size with MEMORY USAGE as the data grows. Give caching, eviction and the application patterns extra time, because most of the practical cases in the final topic depend on them.

This is an independent course. Abekus is not affiliated with or endorsed by Redis Ltd., which owns the Redis trademark.