Design a key-value store in HLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

Identify the main components in a key-value store architecture

Which of the following lists correctly represents the essential components of a scalable key-value store system?

A Client, Load Balancer, Cache, Storage Nodes, Metadata Service

B Client, Load Balancer, File System, DNS Server

C Client, API Gateway, SQL Database, Cache

D Client, Web Server, Database, Authentication Service

💡 Hint

Think about components that handle requests, speed up access, and store data reliably.

A scalable key-value store typically includes clients to send requests, a load balancer to distribute them, a cache for fast access, storage nodes for persistent data, and a metadata service to track data locations.

❓ scaling

intermediate

Scaling a key-value store for high read traffic

If a key-value store experiences very high read traffic but low write traffic, which scaling strategy is most effective to improve read performance?

A Add more storage nodes and replicate data across them

B Reduce the number of replicas to save storage space

C Use a single powerful server with more CPU cores

D Increase the size of each storage node's disk

💡 Hint

Think about how to serve many read requests simultaneously without bottlenecks.

Replicating data across multiple storage nodes allows read requests to be distributed, improving read throughput and reducing latency.

❓ tradeoff

advanced

Choosing consistency model for a distributed key-value store

Which consistency model choice best balances availability and partition tolerance in a distributed key-value store used globally?

A No consistency guarantees, allowing stale reads

B Strong consistency with synchronous replication

C Strict serializability with global locking

D Eventual consistency with asynchronous replication

💡 Hint

Consider the CAP theorem and the challenges of global distribution.

Eventual consistency with asynchronous replication allows the system to remain available and tolerate network partitions, which is important for global systems.

🧠 Conceptual

advanced

Understanding request flow in a key-value store

In a typical key-value store, what is the correct sequence of steps when a client requests a value for a key?

A 2,1,3,4

B 1,3,2,4

C 1,2,3,4

D 1,2,4,3

💡 Hint

Think about the order of checking cache before storage and how the load balancer routes requests.

The client sends the request to the load balancer, which forwards it to the cache. If the cache misses, the storage node is queried. The storage node returns the value to the cache and then to the client.

❓ estimation

expert

Estimating storage requirements for a key-value store

A key-value store holds 1 billion keys. Each key is 32 bytes, and each value is 256 bytes. The system keeps 3 replicas for fault tolerance. Estimate the total storage needed (in terabytes) including 20% overhead for metadata and indexing.

A Approximately 2.8 TB

B Approximately 1.1 TB

C Approximately 1.5 TB

D Approximately 1.8 TB

💡 Hint

Calculate raw data size, multiply by replicas, then add overhead.

Raw data per key-value pair: 32 + 256 = 288 bytes. For 1 billion keys: 288 × 1,000,000,000 = 288 GB. With 3 replicas: 288 GB × 3 = 864 GB. Including 20% overhead: 864 GB × 1.2 ≈ 1,037 GB ≈ 1.1 TB.

Practice

1. What is the primary purpose of a key-value store in system design?

easy

A. To perform complex relational queries

B. To store large binary files efficiently

C. To save data as pairs for quick lookup

D. To manage user authentication and sessions

Solution

1. Step 1: Understand key-value store basics

   A key-value store saves data as pairs where each key maps to a value for fast retrieval.

2. Step 2: Compare with other storage types

   Unlike relational databases, key-value stores do not support complex queries or file storage.

3. Final Answer:

   To save data as pairs for quick lookup -> Option C

4. Quick Check:

   Key-value store = data pairs [OK]

Hint: Key-value stores focus on pairs, not complex queries [OK]

Common Mistakes:

• Confusing key-value store with relational database
• Thinking it handles large files natively
• Assuming it manages user sessions directly

2. Which of the following is the correct operation to add or update a value in a key-value store?

easy

A. exists(key)

B. put(key, value)

C. delete(key)

D. get(key)

Solution

1. Step 1: Identify operation purpose

   Adding or updating a value requires an operation that sets the value for a key.

2. Step 2: Match operation names

   "put" is commonly used to insert or update key-value pairs; "get" retrieves, "delete" removes, "exists" checks presence.

3. Final Answer:

   put(key, value) -> Option B

4. Quick Check:

   Put = add/update [OK]

Hint: Put means add or update a key-value pair [OK]

Common Mistakes:

• Using get to add data
• Confusing delete with update
• Using exists to insert values

3. Given this pseudo-code for a key-value store:

store = {}
store.put('a', 1)
store.put('b', 2)
store.put('a', 3)
value = store.get('a')

What is the value of value after these operations?

medium

A. 3

B. 2

C. 1

D. None

Solution

1. Step 1: Track put operations

   First, key 'a' is set to 1, then 'b' to 2, then 'a' is updated to 3, overwriting previous value.

2. Step 2: Retrieve the value for 'a'

   The last value assigned to 'a' is 3, so store.get('a') returns 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Last put for 'a' = 3 [OK]

Hint: Last put for a key overwrites previous value [OK]

Common Mistakes:

• Assuming first value stays after update
• Confusing keys 'a' and 'b'
• Thinking get returns None if key exists

4. Consider this code snippet for a key-value store:

store = {}
def get_value(key):
    if key in store:
        return store[key]
    else:
        return None

store.put('x', 10)
print(get_value('x'))

What is the main issue preventing this code from working correctly?

medium

A. The put method is not defined for the dictionary

B. The get_value function returns None incorrectly

C. The key 'x' is not added to the store

D. The print statement syntax is wrong

Solution

1. Step 1: Check dictionary operations

   Python dictionaries do not have a put method; they use assignment like store[key] = value.

2. Step 2: Identify error cause

   Calling store.put('x', 10) will cause an AttributeError because put is undefined.

3. Final Answer:

   The put method is not defined for the dictionary -> Option A

4. Quick Check:

   Dicts use assignment, not put [OK]

Hint: Dictionaries use assignment, not put() method [OK]

Common Mistakes:

• Assuming put exists on dict
• Ignoring error from undefined method
• Thinking get_value logic is faulty

5. You want to design a scalable key-value store that handles millions of requests per second. Which design choice best supports this goal?

hard

A. Use a single in-memory dictionary on one server

B. Store all data on a single disk-based database

C. Use a relational database with complex joins

D. Partition data across multiple servers using consistent hashing

Solution

1. Step 1: Understand scalability needs

   Handling millions of requests requires distributing load and data to avoid bottlenecks.

2. Step 2: Evaluate design options

   A single in-memory dictionary or disk-based DB limits capacity; relational DB with joins is slow for key-value access. Consistent hashing partitions data evenly across servers, enabling horizontal scaling.

3. Final Answer:

   Partition data across multiple servers using consistent hashing -> Option D

4. Quick Check:

   Consistent hashing = scalable partitioning [OK]

Hint: Distribute data with consistent hashing for scalability [OK]

Common Mistakes:

• Relying on single server limits throughput
• Using disk-based DB slows access
• Choosing relational DB for simple key-value