Event-driven design in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary benefit of using event-driven design in a distributed system?

Consider a distributed system where components communicate asynchronously. What is the main advantage of using event-driven design in such a system?

A It eliminates the need for any message queues or brokers.

B It forces all components to wait for each other, ensuring strict synchronization.

C It allows components to operate independently and react to events without tight coupling.

D It requires components to share a common database for communication.

💡 Hint

Think about how components communicate and depend on each other in event-driven systems.

Event-driven design enables components to work independently by reacting to events asynchronously, reducing tight coupling and improving scalability.

❓ Architecture

intermediate

Which component is essential in an event-driven architecture to decouple event producers and consumers?

In an event-driven architecture, what component helps to decouple the event producers from the event consumers?

A Event Broker or Message Queue

B Direct API calls between producer and consumer

C Shared Database Table

D Synchronous HTTP Requests

💡 Hint

Think about how events are passed without direct connection between components.

An event broker or message queue acts as an intermediary that stores and forwards events, allowing producers and consumers to operate independently.

❓ scaling

advanced

How does event-driven design improve system scalability compared to synchronous request-response design?

Compare event-driven design with synchronous request-response design. How does event-driven design help improve scalability?

A By forcing all components to wait for responses before continuing, ensuring consistency.

B By allowing components to process events asynchronously, reducing blocking and enabling parallelism.

C By requiring all events to be processed in a single thread to avoid race conditions.

D By eliminating the need for load balancers in the system.

💡 Hint

Think about how asynchronous processing affects resource usage and throughput.

Event-driven design allows components to handle events independently and in parallel, reducing wait times and improving throughput, which enhances scalability.

❓ tradeoff

advanced

What is a common tradeoff when using event-driven design regarding data consistency?

Event-driven systems often sacrifice something to gain scalability and decoupling. What is a common tradeoff related to data consistency?

A Eventual consistency instead of immediate consistency across components.

B Strong consistency with immediate updates everywhere.

C No need for data replication or synchronization.

D Guaranteed order of all events without delay.

💡 Hint

Consider how asynchronous event processing affects the timing of data updates.

Event-driven systems often use eventual consistency, meaning data updates propagate over time rather than instantly, trading immediate consistency for scalability.

❓ estimation

expert

Estimate the maximum event throughput for a system using a single event broker with 10 partitions, each handling 1000 events per second.

A system uses one event broker with 10 partitions. Each partition can handle 1000 events per second. What is the maximum total event throughput the system can handle?

A 100 events per second

B 100,000 events per second

C 1,000 events per second

D 10,000 events per second

💡 Hint

Multiply the number of partitions by the throughput per partition.

The total throughput is the sum of throughput of all partitions: 10 partitions * 1000 events/sec = 10,000 events/sec.

Practice

1. What is the main purpose of event-driven design in system architecture?

easy

A. To allow systems to react to actions as they happen asynchronously

B. To process all tasks sequentially in a fixed order

C. To store data permanently in a database

D. To create static web pages without user interaction

Solution

1. Step 1: Understand event-driven design concept

   Event-driven design focuses on reacting to events or actions as they occur, rather than processing everything in a fixed sequence.

2. Step 2: Compare options with concept

   To allow systems to react to actions as they happen asynchronously matches this idea by describing asynchronous reaction to actions. Other options describe unrelated concepts like sequential processing, data storage, or static content.

3. Final Answer:

   To allow systems to react to actions as they happen asynchronously -> Option A

4. Quick Check:

   Event-driven design = react asynchronously [OK]

Hint: Event-driven means reacting to events as they happen [OK]

Common Mistakes:

• Confusing event-driven with sequential processing
• Thinking event-driven is about data storage
• Assuming event-driven means static content

2. Which of the following is the correct sequence in an event-driven system?

easy

A. Consumer -> Producer -> Queue

B. Producer -> Consumer -> Queue

C. Queue -> Producer -> Consumer

D. Producer -> Queue -> Consumer

Solution

1. Step 1: Identify roles in event-driven flow

   Producers create events, queues hold events, and consumers process events.

2. Step 2: Arrange correct order

   The correct order is Producer sends event to Queue, then Consumer reads from Queue.

3. Final Answer:

   Producer -> Queue -> Consumer -> Option D

4. Quick Check:

   Producer creates, Queue holds, Consumer processes [OK]

Hint: Events flow: Producer to Queue to Consumer [OK]

Common Mistakes:

• Mixing up producer and consumer order
• Placing queue after consumer
• Ignoring the queue role

3. Consider this simplified event-driven code snippet:

event_queue = []

def produce(event):
    event_queue.append(event)

def consume():
    if event_queue:
        return event_queue.pop(0)
    return None

produce('A')
produce('B')
print(consume())
print(consume())
print(consume())

What is the output?

medium

A. None None None

B. B A None

C. A B None

D. A None B

Solution

1. Step 1: Trace event production

   Two events 'A' and 'B' are added to the queue in order: ['A', 'B'].

2. Step 2: Trace event consumption

   consume() removes and returns the first event: first 'A', then 'B', then None when empty.

3. Final Answer:

   A B None -> Option C

4. Quick Check:

   FIFO queue returns A then B then None [OK]

Hint: Queue pops first-in event first (FIFO) [OK]

Common Mistakes:

• Assuming LIFO instead of FIFO
• Forgetting to check empty queue
• Mixing order of events

4. In an event-driven system, a developer wrote this code snippet:

def consume(event_queue):
    event = event_queue.pop()
    process(event)

What is the main issue with this code?

medium

A. It does not check if the queue is empty before popping

B. It adds events instead of removing them

C. It uses an undefined function 'process'

D. It processes events in reverse order, not FIFO

Solution

1. Step 1: Analyze pop usage without check

   pop() removes last item but no check if queue is empty, risking error.

2. Step 2: Identify error risk

   Calling pop() on empty list causes runtime error; code lacks safety check.

3. Final Answer:

   It does not check if the queue is empty before popping -> Option A

4. Quick Check:

   pop() on empty list causes error [OK]

Hint: Always check queue not empty before pop() [OK]

Common Mistakes:

• Ignoring empty queue check
• Confusing pop() order with error
• Assuming process() is undefined error

5. You are designing a scalable event-driven system for a social media app. Which approach best improves scalability and fault tolerance?

hard

A. Store all events in a database and process them synchronously

B. Use a distributed message queue with multiple consumers processing events in parallel

C. Use a single queue and one consumer to ensure event order

D. Send events directly from producer to consumer without queue

Solution

1. Step 1: Understand scalability and fault tolerance needs

   Social media apps have high event volume; parallel processing and fault tolerance are key.

2. Step 2: Evaluate options for scalability

   Distributed queues with multiple consumers allow load balancing and fault tolerance. Single consumer limits throughput. Synchronous processing blocks system. Direct send lacks buffering and fault tolerance.

3. Final Answer:

   Use a distributed message queue with multiple consumers processing events in parallel -> Option B

4. Quick Check:

   Distributed queues + parallel consumers = scalable & fault tolerant [OK]

Hint: Parallel consumers on distributed queue scale best [OK]

Common Mistakes:

• Choosing single consumer limits throughput
• Ignoring asynchronous processing benefits
• Skipping queue leads to lost events