Course · 05

How does Redis stay so fast, and when can it lose your data?

Redis is a data store that lives in memory. This page shows how it works inside, how it saves to disk, how it scales, and the traps interviewers love. Every fact is checked against redis.io and other official docs on 2026-10-25.

—Words you need

Each jargon word once, in plain words glossary

01What Redis is, and why it is fast

RAM, one main thread, an event loop core

Redis means REmote DIctionary Server. It is a key-value store. The value can be a rich data structure, not just a string. All data sits in RAM. Disk is used only to save copies.

Three things make it fast. First, reads never touch disk. Second, one main thread runs every command, so no locks are needed. Third, an event loop with epoll (Linux) lets that one thread watch thousands of sockets. Multiplexing means one thread handles many connections by only working on the ready ones.

Single-threaded means one slow command blocks everyone. That is the price of having no locks.

Source: redis.io latency doc · redis.io FAQ · Redis 6.0 release notes · event library (ae.c)

02Data structures and what each is for

Pick the structure, and the problem often solves itself interview favourite

Redis calls itself a "data structure server". Each type has its own commands, and each command is atomic. Atomic means it runs fully or not at all, with nothing in between.

ZADD game:scores 4200 "ana" 3100 "raj"     # O(log N) per member
ZINCRBY game:scores 50 "raj"              # add points
ZREVRANGE game:scores 0 9 WITHSCORES      # top 10
ZREVRANK game:scores "raj"                # my rank, O(log N)

In an interview, name the data structure first. "Sorted set" answers leaderboard, ranking and time-window questions.

Source: data types · sorted sets · HyperLogLog · bitmaps · GEOADD · memory optimization

03TTL and how keys really expire

Lazy on access, plus a sampling cleaner 10 times a second deep dive

You set a TTL with EXPIRE key 60 or SET key v EX 60. Writing a new value with SET clears the TTL. INCR, LPUSH and HSET keep it.

Add random jitter to TTLs. Many keys expiring in the same second cause latency spikes and cache stampedes.

Source: EXPIRE · latency doc, "Latency generated by expires"

04Eviction when memory is full

maxmemory plus maxmemory-policy core

Set a limit with maxmemory 2gb. When a write would go over it, Redis follows the policy. The default policy is noeviction: writes get an error, reads still work.

Cache: allkeys-lru or allkeys-lfu. Primary data: noeviction and alerts on memory.

Source: Key eviction · redis.conf (default noeviction)

05Persistence: RDB vs AOF vs both

A photo now and then, or a diary of every write interview favourite

"Redis is durable" is a config choice, not a fact. Say which fsync policy, and how much loss you accept.

Source: Redis persistence · latency doc, fork table · FAQ (copy-on-write)

06Replication and Sentinel

Async copies, and a voting group that does failover core

A replica connects and sends PSYNC with the replication ID and the offset it has. An offset is a byte counter of the change stream. If the primary still has those bytes in its backlog (a ring buffer of recent changes), it sends only the gap. If not, it does a full sync: it makes an RDB file, sends it, then streams the buffered writes.

Sentinel gives high availability, not zero data loss. Say "async replication, small window of lost writes" in every answer.

Source: Redis replication · High availability with Redis Sentinel

07Redis Cluster: slots, redirects, limits

16,384 slots, CRC16, MOVED and ASK interview favourite

Sharding means splitting data across machines. Redis Cluster does it with hash slots. HASH_SLOT = CRC16(key) mod 16384. Each primary owns some slots. Clients learn the slot map and talk to the right node directly, with no proxy.

Design keys for the cluster from day one: put things you change together under one hash tag, but do not put everything under one tag, or you create a hot shard.

Source: Redis cluster specification

08Transactions, Lua and pipelining

Three different tools that people mix up deep dive

Need read-decide-write atomically? Use Lua or a Function. Need speed only? Use pipelining.

Source: Transactions · Scripting with Lua · Pipelining

09Pub/Sub vs Streams

Fire-and-forget vs a stored log with acknowledgements core

Pub/Sub for "tell whoever is online now". Streams for "this job must be done". Kafka when you need long retention and replay at large scale (see page 09).

Source: Redis Pub/sub · Redis Streams

10Common patterns

Seven jobs Redis does every day interview favourite

-- KEYS[1]=rl:user:42  ARGV: now_ms, window_ms, limit, request_id
redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ARGV[1] - ARGV[2])
if redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[3]) then
  redis.call('ZADD', KEYS[1], ARGV[1], ARGV[4])
  redis.call('PEXPIRE', KEYS[1], ARGV[2])
  return 1
end
return 0

Most Redis designs are one of these seven. Say which one, the data structure, and the TTL.

Source: INCR (rate limiter pattern) · Lists · FAQ memory footprint

11Distributed locks: SET NX, Redlock, and the debate

Redis docs and Martin Kleppmann disagree; know both sides hard

SET resource_name my_random_value NX PX 30000   # take lock for 30 s, only if free
-- release only if still mine (Lua, or DELEX ... IFEQ on Redis 8.4+)
if redis.call("get",KEYS[1]) == ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end

The random value stops you deleting someone else's lock after yours expired. Redlock takes the same lock on 5 independent primaries and counts it as held only if a majority (3) said yes within the validity time.

Say: "Redis lock for avoiding duplicate work. For money or data correctness, fencing tokens checked by the database, or a consensus store."

Source: Distributed Locks with Redis · Kleppmann, How to do distributed locking · antirez, Is Redlock safe?

12Pitfalls in production

Things that page you at 3 a.m. deep dive

Every pitfall here comes from one root: one thread. Anything O(N) or slow blocks everybody.

Source: KEYS · SCAN · redis-cli · memory optimization · latency doc

13Redis vs Memcached, and the licence story

Both are in-memory; only one is a data-structure server from docs

In interviews, "Redis or Valkey" is the same design answer. Licensing matters for cloud vendors, not for your design.

Source: docs.memcached.org · memcached configuring (4 threads) · memcached.c (1 MB limit) · Redis licence blog 2024 · Valkey launch · Redis AGPLv3 blog 2025

—When to use what

Situation → pick → why decision table

—Common mistakes

What weak answers say traps

—Interview questions

22 questions, easy to design-level, with model answers practice

—Cheat sheet

Numbers and facts to memorise memorise

—Sources

All checked 2026-10-25 sources

—Keep going

Previous and next pages course