Question 1

What is caching, and why is it used?

Accepted Answer

Caching is the process of storing copies of data in a high-speed, temporary storage layer (typically RAM) to serve future requests faster. It is used to reduce latency, decrease load on primary databases, optimize compute resource usage, and improve application throughput and scaling.

Question 2

Explain Cache Hit and Cache Miss.

Accepted Answer

A Cache Hit occurs when requested data is found in the cache layer, allowing it to be returned instantly to the client. A Cache Miss occurs when requested data is not found in the cache. The application must fetch the data from the slower primary storage (database), save a copy in the cache for future requests, and then return it.

Question 3

What is Redis, and what makes it different from other caching databases?

Accepted Answer

Redis (Remote Dictionary Server) is an open-source, in-memory key-value data structure store used as a database, cache, and message broker. Unlike simple caching engines (like Memcached) that only support strings, Redis supports rich data structures (Hashes, Lists, Sets, Sorted Sets, Bitmaps, Streams, HyperLogLogs) and built-in persistence, replication, and clustering.

Question 4

Explain the Cache-Aside (Lazy Loading) caching pattern.

Accepted Answer

In Cache-Aside, the application queries the cache first. If a hit occurs, it returns data. On a miss, the application queries the database, writes the result to the cache, and returns it. This ensures only requested data is cached, but incurs a three-step penalty on cache misses and can lead to stale data if database updates occur.
Code Example:
// Cache-aside logic
function getData(key) {
    let val = cache.get(key);
    if (!val) {
        val = db.query(key);
        cache.set(key, val, TTL);
    }
    return val;
}

Question 5

Explain Write-Through and Write-Behind (Write-Back) caching patterns.

Accepted Answer

In **Write-Through**, the application writes data to the cache, which synchronously writes it to the database before returning. This guarantees data consistency, but adds write latency. In **Write-Behind**, the application writes directly to the cache, which acknowledges the write instantly. The cache asynchronously writes updates to the database in the background. Highly performant, but runs the risk of data loss if the cache crashes before database updates are persisted.

Question 6

What is Time-to-Live (TTL), and why is it important?

Accepted Answer

TTL is the expiration time set on a cache key. Once the TTL duration expires, the key is automatically removed from the cache. TTL is crucial to prevent memory leaks (stale data filling up RAM forever) and ensures the cache eventually updates with fresh database values.

Question 7

List common Redis data structures and their use cases.

Accepted Answer

1. Strings: Text or binary data up to 512MB. Used for basic key-value sessions.
2. Lists: Linked lists of strings. Used for message queues (LPUSH/RPOP).
3. Hashes: Maps of fields and values. Used for representing user profiles/objects.
4. Sets: Unordered collections of unique strings. Used for tracking unique visitors.
5. Sorted Sets: Sets where each element is associated with a score. Used for real-time leaderboards.
6. Pub/Sub: Publisher-subscriber messaging channels.

Question 8

Is Redis single-threaded or multi-threaded?

Accepted Answer

Redis is primarily single-threaded for processing commands. This design avoids synchronization context switches, race conditions, and locking overhead, making execution extremely fast. However, modern Redis (6.0+) uses multi-threading for background operations, such as handling network I/O, deleting large keys, and executing disk persistence tasks.

Question 9

Explain the two persistence models in Redis: RDB and AOF.

Accepted Answer

1. **RDB (Redis Database)**: Creates point-in-time snapshots of dataset memory at specified intervals. Highly compact, fast to restore, but risk of losing data written since the last snapshot.
2. **AOF (Append Only File)**: Logs every write command received by the server to a disk file. Provides maximum durability (using fsync configs), but yields larger files and slower recovery times. Using both models simultaneously is recommended for production environments.

Question 10

What are Redis Eviction Policies? List common ones.

Accepted Answer

When Redis reaches its maximum memory limit (`maxmemory`), it applies eviction policies to free up space:
1. `noeviction`: Returns errors on writes (Default).
2. `volatile-lru`: Evicts the Least Recently Used keys with expiration (TTL) set.
3. `allkeys-lru`: Evicts Least Recently Used keys across the entire database.
4. `volatile-lfu`: Evicts Least Frequently Used keys with expiration set.
5. `volatile-ttl`: Evicts keys with the shortest remaining TTL.

Question 11

What is Cache Penetration, and how do you prevent it?

Accepted Answer

Cache Penetration occurs when clients request keys that exist in neither the cache nor the database. Since they are misses, every request hits the primary database, which can crash the system. Solutions include: caching empty/null results with a short TTL, or using a **Bloom Filter** at the cache gateway to quickly check and block non-existent keys before querying the database.

Question 12

What is Cache Avalanche, and how do you prevent it?

Accepted Answer

Cache Avalanche occurs when a large batch of cached keys expire at the *exact same time*, causing a surge of simultaneous requests to hit the primary database. Prevention strategies include: adding **random jitter/noise** to TTL expirations to stagger cache drops, or using locking/mutexes (cache locks) to let only one request fetch the updated value while others wait.

Question 13

What is Cache Stampede (Cache Breakdown)?

Accepted Answer

Cache Stampede occurs when a highly popular (hot key) expires, and thousands of concurrent requests miss the cache simultaneously, executing redundant database queries. It is solved using mutex locks (only one thread updates cache while others read old cache or wait) or pre-calculating cache updates before expiration.

Question 14

How do you implement a distributed lock in Redis?

Accepted Answer

Distributed locks can be implemented using the `SET` command with the `NX` (set if not exists) and `PX` (expire time) arguments. This guarantees that only one client acquires the lock, and it automatically releases if the client crashes.
Code Example:
// Acquire lock: key="lock_user_1", token="unique_uuid", PX=30000ms
SET lock_user_1 unique_uuid NX PX 30000

// To release, run a Lua script to ensure only the owner can delete the lock
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

Question 15

What is the difference between Redis and Memcached?

Accepted Answer

Memcached is a simple, multi-threaded, in-memory key-value cache that only supports strings. Redis is single-threaded, supports rich data structures (hashes, lists, sets), offers built-in master-slave replication, cluster support, and persistence options, making it more versatile than Memcached.

Question 16

Explain Redis Master-Slave Replication.

Accepted Answer

Redis replication is asynchronous. A Master instance accepts writes, which are replicated to one or more Slave (replica) instances. Slaves are read-only, offloading read queries from the Master. Redis uses **Redis Sentinel** to monitor instances, detect Master failures, and promote a Slave to Master automatically.

Question 17

What is Redis Cluster, and how does it partition data?

Accepted Answer

Redis Cluster provides automatic sharding of data across multiple Redis nodes. It partitions the keyspace into **16,384 hash slots**. The hash slot for a key is calculated as `CRC16(key) mod 16384`. Each node in the cluster is responsible for a subset of hash slots, providing horizontal scaling.

Question 18

What is a Redis Pipeline?

Accepted Answer

Redis Pipeline is a technique to optimize performance by sending multiple commands to the server in a single batch without waiting for individual replies. This reduces network round-trip time (RTT) overhead, improving throughput.

Question 19

What are Redis Transactions?

Accepted Answer

Redis transactions allow executing a block of commands sequentially using the `MULTI`, `EXEC`, `DISCARD`, and `WATCH` commands. Redis transactions are atomic (commands are queued and run as a single block), but they do not support rollback; if a command fails, the others still execute.
Code Example:
MULTI
SET user:1 "Alice"
INCR visitor_count
EXEC

Question 20

How do you handle stale cache data when a database update occurs?

Accepted Answer

Stale data can be managed via:
1. **Cache Eviction on Write**: Active deletion of the cache key when database writes occur (guarantees consistency, preferred).
2. **Short TTL**: Setting a short expiration time so the cache updates automatically (useful for volatile, less critical data).
3. **Pub/Sub Notification**: Publishing write events to an invalidation channel that clients listen to and clear caches accordingly.

Redis & Caching Interview Master

Difficulty Filters

Tools & Options

What is caching, and why is it used?

Explain Cache Hit and Cache Miss.

What is Redis, and what makes it different from other caching databases?

Explain the Cache-Aside (Lazy Loading) caching pattern.

Explain Write-Through and Write-Behind (Write-Back) caching patterns.

What is Time-to-Live (TTL), and why is it important?

List common Redis data structures and their use cases.

Is Redis single-threaded or multi-threaded?

Explain the two persistence models in Redis: RDB and AOF.

What are Redis Eviction Policies? List common ones.

What is Cache Penetration, and how do you prevent it?

What is Cache Avalanche, and how do you prevent it?

What is Cache Stampede (Cache Breakdown)?

How do you implement a distributed lock in Redis?

What is the difference between Redis and Memcached?

Explain Redis Master-Slave Replication.

What is Redis Cluster, and how does it partition data?

What is a Redis Pipeline?

What are Redis Transactions?

How do you handle stale cache data when a database update occurs?

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Ai Ml Interview

Ai Theory Interview

Angular Interview Questions

Artificial Intelligence Interview

Aws Interview Questions

Bitbucket Interview

Follow Us

Our Tools

Our Company

Special Tools