DEVPREP CODEX · #21

Redis Interview Questions

45 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

THEORY QUESTIONS

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·15 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is Redis and what is it used for?

In-memory data structure store (key-value with rich types) usable as cache, message broker, and lightweight database.
Common uses: caching, sessions, rate limiting, leaderboards, queues, pub/sub, distributed locks.
Single-threaded command execution (mostly) → atomic per-command, predictable latency; persistence optional (RDB/AOF).

Q2What data types does Redis provide?

STRING (counters, tokens), LIST (queues via LPUSH/BRPOP), SET (unique members, set ops), HASH (objects), ZSET (sorted sets — leaderboards/ranges).
Plus specialized: Streams (event logs/consumer groups), Bitmaps (presence flags), HyperLogLog (cardinality estimates), Geospatial. Choosing the right type unlocks atomic server-side operations instead of client-side read-modify-write.

Q3What is TTL / key expiration?

EXPIRE key seconds or SET with EX option; TTL auto-deletes keys — the backbone of caching semantics.
TTL returns remaining seconds (-1 no expiry, -2 missing); PERSIST removes expiry.
Expiration is lazy (checked on access) + active sampling cycle — expired-but-uncached keys may linger briefly in memory.

Q4What is the difference between RDB and AOF persistence?

RDB: point-in-time binary snapshots on interval — compact, fast restarts, risk of losing recent writes.
AOF: append-only log of every write — configurable fsync policy (always/everysec/no), better durability, larger files + rewrite compaction.
Hybrid (aof-use-rdb-preamble default modern): fast load + durability. Choose per loss-tolerance budget.

Q5What is a cache hit/miss and how do you compute ratio?

Hit = served from redis; miss = fell through to origin DB.
Ratio = hits/(hits+misses) via INFO stats keyspace metrics.
Low ratios signal wrong TTLs, poor key design, or genuinely uncachable data — investigate before scaling hardware.

10 More Easy Questions Locked

Unlock the complete Redis Easy question bank

Get instant access to all 15 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·15 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1Explain Redis persistence trade-offs: AOF fsync policies and rewrite mechanics.

appendfsync always/everysec/no — durability vs latency spectrum; everysec default losing ≤1s on crash.
AOF rewrite forks child replaying current state into compact new file; copy-on-write memory spike during rewrite is the ops surprise (plan headroom ~2x dataset).
auto-aof-rewrite-percentage triggers sizing; monitor aof_last_bgrewrite_status.

Q2How does replication work and what can be lost on failover?

Asynchronous by default: replicas stream replication feed; WAIT command provides sync acknowledgment option (latency cost).
Failover loses unreplicated writes — min-replicas-to-write guards accepting writes without healthy replicas.
Replicas are read-only serve reads; read-replica staleness visible via master_repl_offset deltas.

Q3What is Sentinel vs Cluster — decision boundaries?

Sentinel: HA for single-master topology (monitoring, automatic failover, client discovery). Data fits one node; scaling = vertical + read replicas.
Cluster: automatic sharding across 16384 hash slots; multi-key ops require same slot (hash tags {}); resharding online. Choose Sentinel for simplicity till dataset/QPS demands sharding; Cluster adds client complexity everywhere.

Q4How do hash slots and hash tags work in Redis Cluster?

CRC16(key) mod 16384 assigns slots; MOVED/ASK redirects guide clients.
Hash tags {user42}.profile and {user42}.cart co-locate related keys enabling MGET/Lua across them.
Resharding migrates slots live via CLUSTER SETSLOT migrating/importing + MIGRATE COPY batches.

Q5What is the atomicity model of Lua scripting (EVAL)?

Script executes atomically mid-command-stream — perfect check-and-set sequences (rate limiter, token bucket).
Constraints: no external reads besides KEYS/ARGV passed (cluster-safe requirement), deterministic scripts only (no random/time without effects flags), script timeout kills blocking.
SCRIPT LOAD + EVALSHA avoids resending bodies; NOSCRIPT fallback handling standard in clients.

10 More Medium Questions Locked

Unlock the complete Redis Medium question bank

Get instant access to all 15 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·15 Questions Total

Internals & System Architecture

Open Full Hard List

Q1How does Redis execute commands internally and what are the latency guarantees/breakers?

Single I/O thread processes command queue atomically (I/O threads parallelize networking in Redis 6+, execution remains serialized) → per-command O(N) costs stall EVERYTHING.
Latency breakers to audit: KEYS/Large DEL/SLOW Lua/Big ZADD batches — SLOWLOG + LATENCY HISTORY diagnose.
Client-side pipelining multiplies throughput without atomicity changes; MULTI differs (queued atomicity).

Q2Explain the unified request layer + RESP3 push types enabling client caching.

RESP3 adds out-of-band push messages separate from reply ordering — foundation of CLIENT TRACKING invalidations.
Tracking modes: exact keys / prefix broadcast; redirect option lets a dedicated tracking connection serve others.
Failure modes: invalidation floods overwhelming slow clients; namespace design + batching mitigates.

Q3What is the full failover sequence under Sentinel, including split-brain guards?

Subjective down (sdown) per sentinel timeout → objective down (odown quorum) → leader sentinel election (raft-ish epoch bump) → replica promotion selection (priority, offset freshness) → reconfiguration propagation.
Split-brain guards: min-replicas-to-write + min-replicas-max-lag cause old-master writes to REJECT during partition, bounding loss window.
Client responsibility: re-query sentinels on role errors; idempotent operations assumed across lost-write windows.

Q4What is Redis Cluster gossip, hash-slot migration state machine, and reshard safety?

Nodes gossip cluster bus (port+10000) sharing slot ownership epochs; config epoch resolves conflicts.
Migration: SETSLOT MIGRATING on source → IMPORTING on target → loop MIGRATE keys (blocking source ops per key) → SETSLOT NODE finalized; ASK redirection during transit honored by smart clients.
Safety: MIGRATE is atomic per key (dump+restore+del), but application multi-key assumptions break mid-reshard — hash tags mandatory discipline.

Q5How would you implement exactly-once consumer semantics over Redis Streams?

Reality: streams give at-least-once. Exactly-once illusion assembled:

Dedup store: processed-id SETNX within same transaction as effect (Lua combining effect+mark atomically when effect target is redis itself).
External-effect dedup: transactional outbox pattern — stream entry written inside DB transaction via CDC relay instead of direct XADD.
PEL reclaim (XAUTOCLAIM) with min-idle-time prevents zombie ownership; delivery counters route poison entries to dead-letter stream.

10 More Hard Questions Locked