Middle Caching & Redis Interview Questions (50 MCQs)

Question 1

What is the main difference between read-through and cache-aside?

Accepted Answer

In read-through the cache layer itself loads from the source on a miss, not the app code

Answer

In read-through data is written to both cache and DB at once

Answer

Read-through never has TTLs while cache-aside does

Answer

Read-through is only used for browser caches

Question 2

What is the main risk of the write-behind (write-back) pattern?

Accepted Answer

If the cache fails before flushing to the DB, writes are lost

Answer

Write latency becomes very high since it waits on the DB

Answer

Reads always miss

Answer

Writes can't be batched

Question 3

Which scenario is write-around suited for?

Accepted Answer

Data that's written but unlikely to be read soon, like logs

Answer

Data read many times right after being written

Answer

When the cache and DB must always be in sync

Answer

When the database is unavailable

Question 4

What problem does refresh-ahead mitigate?

Accepted Answer

Miss latency when hot keys expire, by refreshing them before expiry

Answer

Lost writes when the cache crashes

Answer

Excessive memory usage by big keys

Answer

Inconsistency between Redis replicas

Question 5

Why is deleting the cache key on write usually safer than updating (SET) it?

Accepted Answer

With concurrent writers, SETs can land out of order and leave an old value cached

Answer

Because `DEL` runs faster than `SET` in Redis

Answer

Because SET clears the TTL of every key

Answer

Because deleting disables replication

Question 6

In cache-aside, which write order is more common and less risky?

Accepted Answer

Update the DB first, then delete the cache key

Answer

Delete the cache key first, then update the DB

Answer

Update the cache first, then the DB

Answer

Only update the cache and sync the DB nightly

Question 7

What is the purpose of the delayed double-delete technique?

Accepted Answer

Deleting the key again after a short delay to purge a stale value re-cached by a concurrent reader

Answer

Deleting the key from two different clusters simultaneously

Answer

Writing data to the DB twice for durability

Answer

Deleting a key and its replica with one command

Question 8

What is a cache stampede (thundering herd)?

Accepted Answer

A hot key expires and many concurrent requests miss and all hit the database

Answer

Requests for keys that never exist keep hitting the DB

Answer

Redis evicts all keys because memory is full

Answer

Replicas fall behind the master

Question 9

How can Redis be used to prevent a stampede on one key?

Accepted Answer

Only the request that wins `SET lock:key 1 NX PX 5000` rebuilds; others wait briefly or serve stale

Answer

Set the key's TTL to zero so it never expires

Answer

Find all expired keys with `KEYS *`

Answer

Open a new Redis connection per request

Question 10

Why add a small random jitter to key TTLs?

Accepted Answer

So keys created together don't expire together and spike DB load

Answer

To make keys harder to guess

Answer

So Redis uses less memory

Answer

To speed up replication

Question 11

What problem is called cache penetration?

Accepted Answer

Repeated requests for keys that don't exist in the DB either, so they always miss and hit the DB

Answer

An attacker breaking into a password-less Redis

Answer

Many keys expiring at the same time

Answer

One huge key saturating the network

Question 12

When caching 'not found' results to stop penetration, what matters most?

Accepted Answer

Use a short TTL so a later-created record isn't hidden for long

Answer

Use an infinite TTL so it's never queried again

Answer

Also store the null value in the database

Answer

Cache the entire table instead of null

Question 13

Which Bloom filter property makes it suitable against cache penetration?

Accepted Answer

No false negatives: if it says 'absent', the item is definitely absent

Answer

No false positives: if it says 'present', it definitely is

Answer

It allows deleting elements at no cost

Answer

It stores full records in little memory

Question 14

How does a cache avalanche differ from a cache stampede?

Accepted Answer

An avalanche is many keys or the whole cache lost at once; a stampede is usually one hot key

Answer

An avalanche only happens in Memcached

Answer

An avalanche is requests for nonexistent keys

Answer

No difference; they're two names for one problem

Question 15

What does Redis's `allkeys-lru` policy do?

Accepted Answer

On reaching `maxmemory`, evicts least recently used keys among all keys

Answer

Evicts only keys with a TTL using LRU

Answer

Evicts nothing and returns errors on writes

Answer

Evicts keys with the shortest remaining TTL

Question 16

With `maxmemory-policy noeviction`, what happens when memory is full?

Accepted Answer

Write commands that need memory return an OOM error, but reads still work

Answer

Redis deletes random keys

Answer

Redis swaps data to disk and continues

Answer

Redis crashes immediately and restarts

Question 17

How is LRU implemented in Redis?

Accepted Answer

Approximated: it samples a few keys and evicts the oldest among them (`maxmemory-samples`)

Answer

It keeps an exact linked list of all keys by access order

Answer

It evicts keys alphabetically

Answer

It evicts keys in creation order

Question 18

How does Redis remove expired keys?

Accepted Answer

A mix of lazy (on access) and active (periodic sampling of keys with TTL) expiration

Answer

Only when memory is full

Answer

With a precise timer per key at the exact moment

Answer

Only on server restart

Question 19

What does `MULTI`/`EXEC` guarantee in Redis?

Accepted Answer

Queued commands run in order without interleaving with other clients' commands

Answer

If one command fails at runtime, all previous ones are rolled back

Answer

Data is fsynced to disk before replying

Answer

Commands run atomically across all cluster nodes

Question 20

What role does `WATCH` play in Redis?

Accepted Answer

Optimistic locking: if a watched key changes before `EXEC`, the transaction aborts

Answer

Locks the key so no other client can read it

Answer

Notifies subscribers of key changes

Answer

Pauses the key's TTL until the transaction ends

Question 21

What is the main benefit of running a Lua script with `EVAL` in Redis?

Accepted Answer

The whole script runs atomically on the server, enabling conditional read-modify-write

Answer

The script runs in parallel across several threads

Answer

Lua lets Redis execute SQL queries

Answer

Long scripts have no effect on other clients

Question 22

What does pipelining do in Redis?

Accepted Answer

Sends several commands without waiting for each reply, reducing round-trips

Answer

Runs the commands atomically like a transaction

Answer

Splits commands across several Redis servers

Answer

Stores command output on disk

Question 23

Which statement about `SCAN` is correct?

Accepted Answer

It's incremental with a cursor and may return a key more than once

Answer

It returns exactly `COUNT` keys per call

Answer

It takes a frozen snapshot of keys during iteration

Answer

Like `KEYS`, it blocks the whole server until done

Question 24

What is the main difference between RDB and AOF persistence in Redis?

Accepted Answer

RDB is a periodic point-in-time snapshot; AOF appends every write command to a log

Answer

RDB logs every command; AOF takes periodic snapshots

Answer

RDB is for replicas only and AOF for the master only

Answer

Both keep data only in RAM

Question 25

With AOF and `appendfsync everysec`, how much data can be lost in the worst case?

Accepted Answer

About one second of writes

Answer

No data at all

Answer

Everything since the last RDB snapshot

Answer

Everything, since AOF lives in RAM

Question 26

How does Redis replication work by default?

Accepted Answer

Asynchronous; the master replies before replicas acknowledge

Answer

Fully synchronous; each write waits for all replicas

Answer

Replicas also accept writes and merge with the master

Answer

Replication only happens by manually copying RDB files

Question 27

What does Redis Sentinel do?

Accepted Answer

Monitors master/replicas, performs automatic failover and tells clients the new master

Answer

Shards data across multiple masters via hash slots

Answer

Optimizes and rewrites slow commands

Answer

Uploads daily backups to S3

Question 28

How does Redis Cluster distribute keys across nodes?

Accepted Answer

Each key maps to one of 16384 hash slots via `CRC16(key) mod 16384`

Answer

With consistent hashing on a 2^32 ring

Answer

Round-robin by write order

Answer

By the first letter of the key

Question 29

Why use hash tags like `{user:42}:cart` and `{user:42}:profile` in Redis Cluster?

Accepted Answer

To place both keys in the same slot so multi-key commands and Lua work on them

Answer

To encrypt the keys

Answer

To replicate the keys to every node

Answer

To sync the keys' TTLs

Question 30

What is the weakness of a fixed-window limiter (`INCR` + `EXPIRE` on `rl:user:minute`)?

Accepted Answer

At a window boundary a user can burst up to twice the limit in a short time

Answer

Redis can't increment counters atomically

Answer

A new key is created for every request

Answer

It can't work with multiple app instances at all

Question 31

In a sliding-window limiter using a sorted set, how is each request recorded and counted?

Accepted Answer

`ZADD` with timestamp as score, `ZREMRANGEBYSCORE` to drop old ones, `ZCARD` to count

Answer

`LPUSH` the timestamp and `LLEN` without trimming

Answer

`SADD` the user id and `SCARD` to count

Answer

`PFADD` and `PFCOUNT` for exact counting

Question 32

What is the key property of the token bucket rate-limiting algorithm?

Accepted Answer

Tokens refill at a steady rate and bursts up to bucket capacity are allowed

Answer

Requests leave at a perfectly constant rate with no bursts

Answer

A counter resets at the start of each minute

Answer

Each user can send only one request ever

Question 33

Which command gets a user's rank in a leaderboard where highest score is rank 1?

Accepted Answer

`ZREVRANK board user`

Answer

`ZRANK board user`

Answer

`ZSCORE board user`

Answer

`ZCARD board`

Question 34

What is HyperLogLog in Redis good for?

Accepted Answer

Approximate unique counts (like unique visitors) in ~12KB of fixed memory

Answer

Storing the full ordered list of visitors

Answer

Exact counts with zero error for billions of items

Answer

Storing geographic coordinates

Question 35

Which structure tracks which users (numeric ids) logged in today with minimal memory?

Accepted Answer

A bitmap with `SETBIT daily:2026-11-04 userId 1` and `BITCOUNT`

Answer

A list of user ids

Answer

A hash with a separate key per day and user

Answer

A stream with one entry per login

Question 36

What structure underlies Redis Geo commands like `GEOADD` and `GEOSEARCH`?

Accepted Answer

A sorted set whose score is a geohash of the coordinates

Answer

A separate on-disk R-tree

Answer

A hash with lat and lng fields

Answer

A list sorted by distance

Question 37

What advantage do Redis Streams have over Pub/Sub?

Accepted Answer

Messages persist, with consumer groups, acks and replay from an earlier ID

Answer

Streams deliver only to currently connected subscribers

Answer

Streams use no memory at all

Answer

Streams fully replace Kafka with exactly-once guarantees

Question 38

What problem does a hot key cause in Redis, and what's a common fix?

Accepted Answer

All load lands on one node/shard; spread it with a short local cache or replicated key copies with random suffixes

Answer

The key expires too early; remove its TTL

Answer

The whole cluster's memory fills; run `FLUSHALL`

Answer

Replication stops; remove the replica

Question 39

Why is a big key (e.g. a hash with millions of fields) problematic in Redis?

Accepted Answer

Operations on it (like `DEL` or `HGETALL`) are slow and block the main thread

Answer

Redis forbids hashes with more than 100 fields

Answer

Big keys are never replicated

Answer

Big keys are always auto-compressed and harmless

Question 40

How does `UNLINK` differ from `DEL`?

Accepted Answer

`UNLINK` removes the key from the keyspace immediately but frees memory in a background thread

Answer

`UNLINK` only removes symbolic links between keys

Answer

`UNLINK` deletes the key when its TTL expires

Answer

`UNLINK` removes the key only from replicas

Question 41

Why can grouping small values into small hashes reduce Redis memory usage?

Accepted Answer

Small hashes use a compact encoding (listpack), avoiding per-top-level-key overhead

Answer

Redis gzips hash contents

Answer

Hashes are stored on disk, not in RAM

Answer

Hash fields consume no memory

Question 42

What does `Cache-Control: max-age=60, s-maxage=600` cause?

Accepted Answer

Browsers treat it fresh for 60s and shared caches like CDNs for 600s

Answer

Browsers cache for 600s and the CDN for 60s

Answer

The response is purged everywhere after 60s

Answer

`s-maxage` is valid only for HTTPS responses

Question 43

What does `stale-while-revalidate=30` in `Cache-Control` do?

Accepted Answer

For 30s after expiry, the stale response is served immediately while revalidating in the background

Answer

Forces the cache to purge the response every 30s

Answer

On server errors, serves stale for 30 days

Answer

Delays revalidation for 30 requests

Question 44

What effect does `Vary: Accept-Encoding` have on caches?

Accepted Answer

Caches keep separate variants keyed by the request's `Accept-Encoding` (e.g. gzip or br)

Answer

Disables caching for all requests

Answer

Forces the server not to compress

Answer

Changes the TTL based on encoding

Question 45

Which approach best updates CDN-cached content immediately after a deploy?

Accepted Answer

Versioned URLs (fingerprints) for assets and purges (or surrogate keys) for pages

Answer

Waiting for the one-year TTL to expire

Answer

Changing the origin server's IP

Answer

Adding `no-store` to every response forever

Question 46

In a two-level cache (L1 in-process + L2 Redis), what is the main challenge?

Accepted Answer

Invalidating L1 across all instances on change, e.g. via a Pub/Sub message

Answer

L1 is always slower than L2

Answer

Redis forbids coexisting with a local cache

Answer

L2 must always be smaller than L1

Question 47

What does request coalescing (singleflight) do in a service?

Accepted Answer

Merges concurrent requests for the same key so one load runs and all share its result

Answer

Spreads requests across several Redis servers

Answer

Compresses responses to reduce size

Answer

Rejects duplicate requests with 429

Question 48

What is wrong with running `INCR key` then a separate `EXPIRE key 60` in a rate limiter?

Accepted Answer

If the process crashes between them, the key has no TTL and the user stays limited forever

Answer

`EXPIRE` resets the counter to zero

Answer

`INCR` errors on a missing key

Answer

Two commands can never run within one second

Question 49

Why shouldn't critical logic (like cancelling orders) rely on `expired` keyspace notifications?

Accepted Answer

They're sent via Pub/Sub (not durable) and may fire later than the actual TTL

Answer

Redis never emits expired events

Answer

The expired event fires before the key expires

Answer

It only works in Redis Cluster

Question 50

Which approach to choosing TTLs is most sensible?

Accepted Answer

Set each data type's TTL from its change rate and staleness tolerance, combined with explicit invalidation

Answer

One fixed 24-hour TTL for every key in the system

Answer

No TTLs, relying entirely on eviction

Answer

A tiny 1-second TTL for all data so it's never stale