Senior Caching & Redis Interview Questions (50 MCQs)

Question 1

In cache-aside with 'update DB then delete cache', which scenario can still leave a stale value cached for a long time?

Accepted Answer

A reader that loaded the old value on a miss performs its SET after the writer's delete

Answer

Two readers concurrently cache the new value

Answer

The writer deletes twice in a row

Answer

The key's TTL is shorter than the transaction

Question 2

How can you ensure a slow reader never overwrites a newer cached value with an older one?

Accepted Answer

Store a version (e.g. row version or `updated_at`) and use a Lua script that writes only if the version is newer

Answer

Use `SET ... XX` so only existing keys are overwritten

Answer

Pipeline every SET

Answer

Increase `maxmemory-samples`

Question 3

What is the advantage of CDC-based invalidation (e.g. Debezium on binlog/WAL) over deleting in app code?

Accepted Answer

It sees only committed changes, covers every write path (even manual scripts) and is retryable

Answer

It invalidates fully synchronously with zero lag

Answer

It removes the need for TTLs forever

Answer

It reduces DB read load to zero

Question 4

How does probabilistic early expiration (XFetch) prevent stampedes?

Accepted Answer

Each reader may recompute early with a probability that grows near expiry (scaled by recompute cost)

Answer

All readers recompute together exactly at expiry

Answer

Keys never expire and only leave via eviction

Answer

It takes a global lock on the entire cache

Question 5

What does the soft TTL + hard TTL pattern provide?

Accepted Answer

After the soft TTL stale data is served while refreshing in the background; the hard TTL caps staleness and enables serving during origin outages

Answer

It keeps two copies of each key in separate clusters

Answer

It sets TTL based on value size

Answer

It removes keys only through eviction

Question 6

Which statement about Redis 6+ threading is accurate?

Accepted Answer

Commands execute on one thread, but network I/O and lazy freeing can use helper threads

Answer

Each command runs on its own parallel thread

Answer

Redis 6 became fully multi-threaded and dropped command atomicity

Answer

Redis forks a process per client

Question 7

Why can memory nearly double during `BGSAVE` on a write-heavy Redis?

Accepted Answer

Fork uses copy-on-write, so every page modified in the parent gets copied

Answer

Redis serializes all data into a new buffer before saving

Answer

Replicas copy data into the master's memory

Answer

AOF keeps all data twice in RAM

Question 8

What is the main criticism (e.g. by Martin Kleppmann) of Redlock for correctness-critical locks?

Accepted Answer

It relies on timing and clocks; GC pauses or clock jumps can let two clients believe they hold the lock

Answer

Redlock requires over 100 Redis nodes

Answer

Redlock never releases locks

Answer

Redlock only works on Memcached

Question 9

How does a fencing token work with a distributed lock?

Accepted Answer

Each acquisition returns an increasing number, and the target resource rejects writes with a token lower than the last seen

Answer

The token is a random secret that encrypts the lock

Answer

The token sets how many retries a client gets

Answer

The token is only for logging and has no effect

Question 10

What is the correct way to release a lock taken with `SET lock val NX PX 30000`?

Accepted Answer

A Lua script that `DEL`s only if `GET lock` equals this client's unique value

Answer

Just run `DEL lock`

Answer

`GET lock`, then a separate `DEL` if it matches

Answer

`EXPIRE lock 0` from any client

Question 11

Why can a lock on a single Redis master with a replica and Sentinel violate safety?

Accepted Answer

Replication is async; the master may die before shipping the lock key, so the promoted replica lacks it

Answer

Sentinel deliberately deletes all locks on failover

Answer

Replicas don't support `NX`

Answer

Sentinel resets all nodes' clocks

Question 12

What restriction does Redis Cluster impose on transactions and Lua scripts?

Accepted Answer

All involved keys must be in one hash slot and be passed explicitly as KEYS

Answer

Transactions are entirely forbidden in Cluster

Answer

Scripts run atomically across all masters

Answer

Only 10 keys are allowed per script

Question 13

Why does Redis Cluster use 16384 slots?

Accepted Answer

The slot bitmap in gossip heartbeats stays small (2KB) and suffices for up to ~1000 masters

Answer

Because CRC16 can only output values up to 16384

Answer

Because each node can hold at most 16384 keys

Answer

Because 16384 equals the OS's free port count

Question 14

What is the difference between `MOVED` and `ASK` redirects in Redis Cluster?

Accepted Answer

`MOVED` means the slot moved permanently and the client should update its map; `ASK` is temporary, for that request during migration

Answer

`ASK` is permanent and `MOVED` temporary

Answer

Both mean the node is down

Answer

`MOVED` is only sent for replicas

Question 15

When is Sentinel a better choice than Cluster?

Accepted Answer

When data and throughput fit one node and you need free multi-key ops, unrestricted Lua and multiple databases

Answer

When data exceeds a single machine's RAM

Answer

When you need linear write scaling across masters

Answer

When automatic failover isn't needed

Question 16

What risk do `min-replicas-to-write` and `min-replicas-max-lag` reduce?

Accepted Answer

An isolated master in a partition accepting writes that are lost after failover

Answer

Memory filling up due to big keys

Answer

Stampedes on hot keys

Answer

Slowness of the `KEYS` command

Question 17

After a brief network blip, what determines whether a replica can partial-resync instead of doing a full sync?

Accepted Answer

Whether the missed offset is still in the master's replication backlog (`repl-backlog-size`)

Answer

Whether the replica uses AOF

Answer

The number of keys with TTLs

Answer

The replica's `maxmemory-policy`

Question 18

What problem does AOF rewrite (`BGREWRITEAOF`) solve?

Accepted Answer

Unbounded AOF growth, by producing the minimal commands to rebuild current state

Answer

Checksum errors in the RDB file

Answer

Lag between master and replica

Answer

Unencrypted data on disk

Question 19

For a Redis used purely as a cache (truth lives in the DB), which configuration is usually most sensible?

Accepted Answer

Persistence off or occasional RDB, `allkeys-lru`/`allkeys-lfu`, and a plan for cold starts

Answer

AOF with `appendfsync always` and `noeviction`

Answer

`volatile-ttl` with no TTLs on any keys

Answer

Disable `maxmemory` and let the OS swap

Question 20

How does Redis LFU (`allkeys-lfu`) track access frequency?

Accepted Answer

With an 8-bit logarithmic counter that increments probabilistically and decays over time

Answer

With an exact 64-bit counter per key and no decay

Answer

By logging every access timestamp in a list

Answer

By counting bytes read

Question 21

Why does `SCAN` never miss a key present for the whole iteration, even as the dict rehashes?

Accepted Answer

The cursor advances by reverse-binary iteration over high bits, which stays valid across table resizes

Answer

Redis blocks rehashing during SCAN

Answer

SCAN takes a full keyspace copy

Answer

SCAN returns keys alphabetically

Question 22

What structure backs large Redis sorted sets, giving O(1) `ZSCORE` and O(log N) range queries?

Accepted Answer

A skip list (for order and rank) combined with a hash table (member to score)

Answer

An on-disk B-tree

Answer

A sorted array fully re-sorted on every insert

Answer

A binary heap

Question 23

In a sorted-set leaderboard, how do you rank the player who reached a score first higher on ties?

Accepted Answer

A composite score like `points * 1e10 + (MAX_TS - timestamp)` within double precision

Answer

Redis orders ties by insertion time automatically

Answer

Use `ZADD ... GT` for all players

Answer

Store players in a list instead

Question 24

For an API with millions of users and a 10,000/hour limit, why is a sliding window counter usually preferred over a sliding log (sorted set)?

Accepted Answer

A sliding log stores one member per request and blows up memory; a weighted two-window counter is O(1) memory

Answer

A sliding log is not accurate at all

Answer

Sorted sets aren't supported in Cluster

Answer

The counter has zero approximation error

Question 25

For global rate limiting across regions with high inter-region latency, which approach is more practical?

Accepted Answer

Per-region local quotas with async synchronization, accepting slight overshoot

Answer

One central Redis that every region hits synchronously per request

Answer

Redlock across all regions on every request

Answer

Disable rate limiting for distant regions

Question 26

Which method is least risky for detecting hot keys in production Redis?

Accepted Answer

`redis-cli --hotkeys` under an LFU policy, or client/proxy-side sampling

Answer

Running `MONITOR` for a long time on a busy master

Answer

Running `KEYS *` and counting manually

Answer

`DEBUG SLEEP` to slow traffic and observe

Question 27

A 50M-field hash (`user:settings`) causes memory imbalance in Cluster. What's an appropriate fix?

Accepted Answer

Bucket into many hashes like `user:settings:{id % 1024}` so they spread across slots

Answer

Add more replicas to the same shard

Answer

Switch `maxmemory-policy` to `noeviction`

Answer

Read it with `HGETALL` on every request

Question 28

What does Redis 6 client-side caching (`CLIENT TRACKING`) do?

Accepted Answer

The server tracks keys a client read and pushes invalidation messages to it when they change

Answer

Redis copies and syncs data directly into client memory

Answer

It controls browser caching via HTTP headers

Answer

It caches read commands on replicas

Question 29

In a multi-level cache (local L1, Redis L2, DB), what is the correct invalidation order after a write?

Accepted Answer

Commit to DB, then invalidate L2, then broadcast to invalidate L1 on all instances

Answer

Invalidate L1, then DB, then L2 only on that instance

Answer

Invalidate only L1; L2 syncs itself

Answer

Order doesn't matter since everything is synchronous

Question 30

After an accidental full Redis flush at peak hours, what's the first step to protect the database?

Accepted Answer

Enable load shedding/rate limiting and request coalescing, and gradually warm hot keys

Answer

Immediately raise every TTL to a week

Answer

Restart all application servers

Answer

Disable caching entirely until night

Question 31

What is the key limitation of a standard Bloom filter against penetration when records get deleted?

Accepted Answer

It can't remove elements; you need a counting/cuckoo filter or periodic rebuilds

Answer

It produces false negatives and rejects existing records

Answer

Its memory grows with request count

Answer

It only works with numeric keys

Question 32

Why is deleting the cache key inside the DB transaction (before commit) a bad idea?

Accepted Answer

A concurrent reader may re-cache the old value before commit, and a rollback causes needless invalidation

Answer

Redis rejects commands inside SQL transactions

Answer

It automatically rolls back the DB transaction

Answer

It causes deadlocks in Redis

Question 33

In write-behind with multiple workers flushing the write queue, what is critical for correctness?

Accepted Answer

Preserving per-key write order (e.g. partition by key) and idempotent flushes

Answer

Flushing in random order to spread load

Answer

Removing all TTLs

Answer

Using `KEYS` to find dirty keys

Question 34

Why is client-side Memcached sharding with `hash(key) % N` problematic when adding a node, and what's the alternative?

Accepted Answer

Almost all keys remap causing mass misses; consistent hashing moves only about 1/N of keys

Answer

Memcached doesn't support adding nodes

Answer

Only keys on the new node are lost

Answer

mod N is unbalanced but causes no remapping

Question 35

When can Memcached be a better choice than Redis?

Accepted Answer

A simple high-volume blob cache benefiting from multithreading on many-core boxes and a predictable slab allocator

Answer

When sorted sets for leaderboards are needed

Answer

When built-in persistence and replication are required

Answer

When Pub/Sub and Streams are needed

Question 36

Redis shows periodic latency spikes of hundreds of ms. Which cause is most likely?

Accepted Answer

Fork for RDB/AOF rewrite on a large dataset, or mass expiry/deletion of big keys

Answer

Using `GET` instead of `MGET`

Answer

Keys having short names

Answer

Having `maxmemory-policy allkeys-lru` enabled

Question 37

A Lua script loops over a big collection and runs for 5 seconds. What's the consequence?

Accepted Answer

The server serves no other commands meanwhile and after `busy-reply-threshold` replies only `BUSY`

Answer

Redis runs it in the background and serves others in parallel

Answer

The script auto-rolls back after 1 second

Answer

The script is split and spread across replicas

Question 38

What advantage do Redis Functions (`FUNCTION LOAD`/`FCALL` in Redis 7) have over `EVALSHA`?

Accepted Answer

Functions are part of the dataset; they persist and replicate, surviving restarts and failovers without reloading

Answer

Functions run multi-threaded

Answer

Functions lift Cluster's cross-slot limits

Answer

Functions are non-atomic and therefore faster

Question 39

In Redis Streams with consumer groups, what happens if a consumer reads a message and crashes before `XACK`?

Accepted Answer

It stays in the Pending Entries List and another consumer can take it via `XAUTOCLAIM`/`XCLAIM` after idle time

Answer

The message is permanently removed from the stream

Answer

Redis immediately auto-redelivers it to another consumer

Answer

The entire consumer group is deleted

Question 40

Which is the most efficient way to keep a high-traffic stream's memory bounded?

Accepted Answer

`XADD stream MAXLEN ~ 1000000 * ...` with approximate trimming

Answer

Exact `MAXLEN = 1000000` on every `XADD`

Answer

Deleting messages manually with `XDEL` in a per-minute cron

Answer

Setting a TTL on each stream entry

Question 41

What is the main trade-off between Redis-stored sessions and stateless JWTs?

Accepted Answer

Redis enables instant revocation but adds a lookup per request and an infrastructure dependency

Answer

JWTs make instant revocation easier than Redis

Answer

Redis sessions can't expire

Answer

A JWT is always smaller than a session id

Question 42

An attacker hits CDN-cached pages with random query strings (`?x=123`). What happens and how do you mitigate it?

Accepted Answer

Every request misses and reaches origin; normalize the cache key (whitelist params) plus WAF/rate limiting

Answer

The CDN serves them all from one cached response, no issue

Answer

The CDN automatically blocks the attacker's IP

Answer

The origin serves from memory so there's no effect

Question 43

How does web cache poisoning via an unkeyed header (e.g. `X-Forwarded-Host`) happen?

Accepted Answer

The app reflects the header in the response but it's not in the cache key, so a poisoned response is cached for everyone

Answer

The attacker gains direct access to Redis

Answer

It sets the response TTL to zero

Answer

The user's browser decrypts the cache

Question 44

For a page that is 95% public and 5% personalized (username, cart), which approach maximizes CDN hit ratio?

Accepted Answer

Cache the public shell at the CDN and load the personal part separately (client fetch or ESI/edge compute)

Answer

`Vary: Cookie` on the whole page

Answer

`Cache-Control: private` on the whole page

Answer

Caching a separate copy per user at the CDN

Question 45

When a product change must invalidate dozens of cache keys (product page, category lists, search results), which pattern scales better?

Accepted Answer

Namespace versioning: keys embed the current version like `cat:5:v{n}:page:1`, invalidated by `INCR`-ing it

Answer

Run `KEYS cat:5:*` and delete the results

Answer

`FLUSHDB` after every product change

Answer

A one-year TTL and waiting for expiry

Question 46

Why can an overall 99% hit ratio be misleading?

Accepted Answer

The 1% misses may be the most expensive queries, driving most DB load and tail latency

Answer

Any hit ratio above 95% always signals a broken cache

Answer

Redis always reports double the hit ratio

Answer

Hit ratio has no relation to performance

Question 47

Doubling cache size from 10GB to 20GB moved hit ratio only from 90% to 91%. What does that indicate?

Accepted Answer

The hot working set already fit; most misses are compulsory or invalidation/TTL-driven, not capacity

Answer

Redis only uses the first 10GB

Answer

The eviction policy should be `noeviction`

Answer

Hit ratio is linear in size, so the measurement is wrong

Question 48

A service deletes the cache key after writing to the primary DB, and the next read refills from a DB replica. What goes wrong?

Accepted Answer

If the replica lags, the old value gets re-cached and persists until TTL

Answer

Replicas don't allow reads

Answer

The cache automatically reads from the primary

Answer

No problem, replication is always synchronous

Question 49

Which measure matters most when securing Redis in production?

Accepted Answer

Never expose it publicly, enable ACLs/auth and TLS, and restrict dangerous commands like `FLUSHALL` and `CONFIG`

Answer

Changing the port to 6380 is enough

Answer

Disabling persistence

Answer

Increasing `maxmemory`

Question 50

Why does pipelining or `MGET` over 1000 random keys perform worse in Redis Cluster than on a single node?

Accepted Answer

Keys span slots and nodes; the client must split by node and make several parallel round-trips

Answer

Cluster disables pipelining entirely

Answer

Every key is copied to all nodes in Cluster

Answer

`MGET` in Cluster returns only the first key