roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Explain what Redis keeps in memory and where it fits in a system, at the depth interviews probe. Covers data types, caching, persistence, atomicity, replication, clustering, security and operations.
554 of 554 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 554 new. 0 cut, outside your plan.
Redis questions rarely open a round; they surface inside one about something larger. Backend candidates usually meet them in system design, as the cache in front of the database, the counter behind a rate limiter or the lock that keeps two workers off one job. SRE and platform interviewers start from a broken deployment instead: an instance out of memory, a replica fallen behind, a server that stalls every client at once.
The probes are small and mechanical. Why does KEYS * on a busy instance freeze everyone, and what does SCAN give up to avoid that? A rate limiter calls INCR and then EXPIRE; what becomes of the counter if the client dies between the two? A lock taken with SET and NX plus a timeout is released with a plain DEL; whose lock does that delete when the holder overran its lease? Why does a MULTI/EXEC block that hits a type error halfway leave the earlier commands applied?
Lower in the level range, a good answer picks the right type and command. Higher up, the same question comes with a failure attached, and the answer names what is lost and what the fix costs: writes a replica never received before its promotion, the memory a fork-based snapshot needs while the parent keeps writing, one hot key pinning a shard while its neighbors idle.
The opening module puts the role before the product and asks what a store that lives in memory is for: the volatile tier and the workloads built on ephemeral state separate what may live only there from what must not, and choosing a datastore adds the case where Redis is the wrong answer. Design rounds test that judgment before any command is named.
Core Engine is then Redis by name, the Redis hub: types and commands, the query engine, ACLs and TLS, the event loop and the tools an operator reaches for. Most modules after it are product-neutral and return to its subjects for the mechanism beneath each command. Value shapes and keyspace design decide what a key holds and how keys are found again without a full scan; expiry closes that module because the caching patterns next, caching at scale and cache-aside, lean on a lifetime.
The middle of the plan puts the tier under stress. The memory ceiling is where expiry by time gives way to eviction by pressure, and durability options name the writes a restart loses. Atomicity and the cost of each access follow: one thread runs commands in sequence, which makes a single command atomic and a single slow one everyone's problem.
The last stretch leaves the single instance. Spreading the tier covers replication, failover and which node owns a key without naming a product; Redis's own failover for unsharded deployments, Sentinel, is covered back in the Core Engine hub, beside Cluster. Operating the tier turns it into signals, slowdowns to diagnose and who can reach the port, and Redis Insight, Redis's official GUI, lets you browse keys and read slow commands and memory use in one place. Redis Enterprise, the vendor's commercial build, closes the plan.
Where Redis sits beside the main stack in a backend posting and only a couple of weeks remain before the loop, Core Engine and Caching Patterns repay the hours, since a design round usually finds its Redis question there. Narrowing level to the seniority on the posting and raising importance to must know trims the later modules down to the follow-ups a cache answer invites. If you have only met Redis through a framework's caching annotation, read the opening module first. Platform and SRE candidates are asked about the second half, from Memory & Durability on, with ACLs, TLS and the operator's tools back in Core Engine, and a failover answer there borrows the loss window from durability and the replication lag from High Availability; that dependence is the reason to switch study order to by topics here rather than hop between modules by frequency. Keep a local instance open: `INFO memory`, `SLOWLOG GET` and `redis-cli --bigkeys` are easier to discuss once you have read their output. Redis is usually one box in a larger design. Load balancing, the primary database behind the cache and how it is sharded belong to the [System Design roadmap](/roadmaps/system-design). When events must outlive memory and be replayed days later by independent consumers, the partitioned log on disk is the [Apache Kafka roadmap](/roadmaps/kafka)'s subject.
Where Redis sits beside the main stack in a backend posting and only a couple of weeks remain before the loop, Core Engine and Caching Patterns repay the hours, since a design round usually finds its Redis question there. Narrowing level to the seniority on the posting and raising importance to must know trims the later modules down to the follow-ups a cache answer invites. If you have only met Redis through a framework's caching annotation, read the opening module first.
Platform and SRE candidates are asked about the second half, from Memory & Durability on, with ACLs, TLS and the operator's tools back in Core Engine, and a failover answer there borrows the loss window from durability and the replication lag from High Availability; that dependence is the reason to switch study order to by topics here rather than hop between modules by frequency. Keep a local instance open: INFO memory, SLOWLOG GET and redis-cli --bigkeys are easier to discuss once you have read their output.
Redis is usually one box in a larger design. Load balancing, the primary database behind the cache and how it is sharded belong to the System Design roadmap. When events must outlive memory and be replayed days later by independent consumers, the partitioned log on disk is the Apache Kafka roadmap's subject.