Question 1

Explain Redis eviction policies and how to configure LRU caching.

Accepted Answer

When Redis memory limits are reached, it evicts keys based on policies configured using `maxmemory-policy`. Common policies include:
- `volatile-lru`: Evicts the least recently used keys with expiration TTLs.
- `allkeys-lru`: Evicts any least recently used key regardless of TTL.
- `noeviction` (Default): Returns errors on write attempts once memory is full.

Question 2

What are Redis Transactions and how do you execute one?

Accepted Answer

Redis transactions queue commands for sequential execution using `MULTI` and `EXEC`:
```redis
MULTI
SET user:1 "John"
SADD active_users 1
EXEC
```
All commands run sequentially without interruption. If a command fails, Redis does not support rollbacks; remaining commands still execute.

Question 3

How do you implement a distributed lock in Redis using Redlock?

Accepted Answer

To implement a safe distributed lock across multiple independent Redis nodes: acquire a lock on all nodes using `SETNX` with a unique token and timeout. The lock is acquired only if a majority of nodes confirm write within the timeout, preventing split-brain lock states.

Question 4

How do you write unit tests for Redis integration using mock client libraries?

Accepted Answer

Use libraries like `ioredis-mock` or mock Redis clients (using Jest mocks). Stub `get`, `set`, and `incr` calls to return mock strings or values directly to isolate service class tests.

Question 5

Explain Redis Pipeline and how it optimizes round-trip times.

Accepted Answer

Pipelining allows sending multiple commands to the Redis server in a single network request without waiting for individual replies. The server processes all commands and returns replies in a single batch, reducing network latency.

Question 6

What are Redis Sorted Sets and when are they configured?

Accepted Answer

Sorted Sets (ZSET) store unique strings mapped to numeric scores. They are kept sorted. Use them for real-time leaderboards, rate limiters, or scheduling queues.

Question 7

How do you detect memory bottlenecks in Redis using memory usage commands?

Accepted Answer

Run `INFO memory` to inspect active memory metrics. Monitor `used_memory_rss` (physical memory allocated) and check fragmentation ratios: high fragmentation suggests memory release delays.

Question 8

How do you mock Redis Sentinel setups during testing?

Accepted Answer

Mock the Sentinel client class (using Jest or Mockito). Stub connection methods to return mock client instances, allowing tests to simulate failovers without active clusters.

Question 9

Explain Redis Sentinel and how it provides high availability.

Accepted Answer

Redis Sentinel manages master-replica setups. Sentinels monitor nodes, check master health, and automatically promote a replica to master if the master crashes, notifying clients.

Question 10

What is the purpose of the Redis keys command and why is it dangerous?

Accepted Answer

The `KEYS pattern` command scans the database looking for matching keys. Because Redis is single-threaded, running `KEYS` on large databases blocks execution for seconds, degrading API response times. Use `SCAN` instead.

Question 11

Explain how to implement rate limiting in Redis using sorted sets.

Accepted Answer

For a rolling-window rate limiter, log request timestamps as sorted set scores. Use `ZREMRANGEBYSCORE` to remove logs older than the time window, count items using `ZCARD`, and block requests if limits are exceeded.

Question 12

What is the difference between Redis AOF fsync options?

Accepted Answer

Configure `appendfsync` options: `always` (fsync on every write, safe but slow), `everysec` (fsync once per second, default balance), or `no` (delegates fsync to the OS, fast but risky).

Question 13

How do you test Redis pub/sub channels in integration tests?

Accepted Answer

Create separate publisher and subscriber clients. Subscribe to a channel inside test hooks, publish a message from the publisher, and assert that the subscriber receives the message.

Question 14

Explain how to execute Lua scripting inside Redis.

Accepted Answer

Use the `EVAL` command. Lua scripts run atomically on the Redis server, letting you execute complex logic (like transaction checks) in a single step without network round-trips.

Question 15

What is memory fragmentation in Redis and how do you resolve it?

Accepted Answer

Memory fragmentation occurs when the OS allocator retains empty pages after Redis deletes keys. Configure `activedefrag yes` to defragment memory dynamically in the background.

Question 16

How do you manage Redis connection leaks in application clients?

Accepted Answer

Always reuse Redis client connections (use singleton clients). Monitor active connections using `CLIENT LIST` to identify leaks where clients are instantiated on every request.

Question 17

Explain the Redis Cluster Architecture, detailing Hash Slots, Master-Replica Sharding, and Failover mechanics.

Accepted Answer

Redis Cluster provides horizontal scaling and high availability. Key design components:
1. Hash Slots: The cluster space is divided into 16,384 logical hash slots. Keys are mapped to slots using CRC16 hashing: `slot = CRC16(key) % 16384`.
2. Sharding: Slots are distributed across multiple Master nodes. Each Master has Standby Replicas.
3. Failover: Nodes monitor health using gossip protocols. If a Master crashes, replicas elect a new Master. Clients read cluster topology and redirect queries dynamically if slot mappings change.

Question 18

How would you design and implement a distributed rate limiter in Redis capable of handling 100k+ API requests per minute?

Accepted Answer

To scale rate-limiting under high traffic:
- Lua Scripting: Write a Lua script executing the token-bucket algorithm atomically on the server to avoid network round-trip latency.
- Data Structure: Use Redis Hashes to store bucket states (tokens, last refill timestamp).
- Execution: Call the script using `EVALSHA` to reuse compiled scripts, caching scripts in Redis memory. If tokens are available, decrement the count and return success; otherwise, block the request.

Question 19

Explain Redis memory optimization techniques: ziplist/listpack conversions and virtual memory allocation.

Accepted Answer

Redis optimizes memory by using compact internal structures for small collections. For example, small Hashes or Sorted Sets are stored as `ziplist` or `listpack` (flat byte arrays) instead of hash tables. Once the collection size or element count exceeds limits (configured via `hash-max-ziplist-entries`), Redis converts them to standard dictionary maps. Optimize by keeping collection sizes below thresholds to save memory.

Question 20

Explain how to secure a Redis cluster in production, focusing on ACLs, SSL/TLS, and network isolation.

Accepted Answer

Secure Redis by:
1. Access Control Lists (ACLs): Disable default users, and create users with strict command limits (e.g. blocking admin commands like `FLUSHALL` or `CONFIG`).
2. SSL/TLS: Enable TLS in configurations to encrypt client-server communication.
3. Network Isolation: Bind Redis exclusively to internal private network interfaces (`bind 127.0.0.1 10.0.0.5`), and set strong passwords via `requirepass`.

Question 21

How do you handle Redis cache stampede (thundering herd) and cache penetration in high-traffic architectures?

Accepted Answer

Mitigate cache issues by:
- Cache Stampede: When a hot cache key expires, concurrent requests query the DB simultaneously. Resolve by using mutual exclusion locks (SETNX) so only one thread queries the DB and updates the cache while others wait.
- Cache Penetration: When requests query keys that never exist, hitting the DB. Resolve by caching empty results with short TTLs or using Bloom Filters.

Question 22

Explain the latency implications of Redis single-threaded execution when running O(N) commands.

Accepted Answer

Since Redis is single-threaded, running O(N) commands (like `KEYS`, `SMEMBERS`, or sorting massive sets) blocks the event loop. This blocks all subsequent client requests, causing API timeouts. Always use incremental search commands like `SCAN` or `HSCAN`.

Question 23

How do you run hot-reloading configurations in Redis clusters without downtime?

Accepted Answer

Modify parameters dynamically using the `CONFIG SET` command. Once verified, run `CONFIG REWRITE` to write the updates to the `redis.conf` file, ensuring changes persist across restarts.

Senior Redis Interview Questions (5+ Years Experience) (2026)

What is Redis and Why is it Critical in Modern Engineering?

Redis Lifecycle Visualizer

Core Architectural Concepts in Redis

In-Memory Data Structures

RDB & AOF Persistence

Single-Thread Event Loop

Eviction Policies (LRU)

Redis Cluster Hash Slots

check_circleWhy Modern Companies Choose Redis

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Performance