When to use which behavioral pattern in LLD - Scalability & System Analysis

Scalability Analysis - When to use which behavioral pattern

Growth Table: Behavioral Patterns Usage at Different Scales

Scale	Typical Use Case	Behavioral Pattern Focus	Complexity Impact
100 users	Simple workflows, few interactions	Strategy for flexible algorithms	Low complexity, easy to maintain
10K users	Multiple user roles, dynamic behavior	Observer for event handling, Command for undo/redo	Moderate complexity, need clear communication
1M users	High concurrency, asynchronous events	Mediator to reduce coupling, State for complex states	High complexity, requires decoupling and scalability
100M users	Distributed systems, microservices	Chain of Responsibility for request routing, Visitor for analytics	Very high complexity, patterns help modularity

First Bottleneck

At small scale, the main challenge is managing code complexity as behaviors grow. Without patterns, code becomes hard to change.

At medium scale, event handling and communication between components become bottlenecks, causing delays and bugs.

At large scale, tight coupling between components slows down development and system responsiveness.

At very large scale, distributed coordination and consistent behavior across services become bottlenecks.

Scaling Solutions Using Behavioral Patterns

• Strategy: Use to swap algorithms easily, reducing code duplication and improving flexibility.
• Observer: Decouple event producers and consumers, enabling scalable event-driven systems.
• Command: Encapsulate requests for undo/redo and queueing, improving control flow.
• Mediator: Centralize communication to reduce dependencies and improve maintainability.
• State: Manage complex state transitions cleanly, avoiding large conditional logic.
• Chain of Responsibility: Pass requests along a chain to handle them flexibly, useful in distributed request routing.
• Visitor: Separate operations from object structures, helpful for analytics and reporting without changing core logic.

Back-of-Envelope Cost Analysis

Behavioral patterns mainly affect development and maintenance costs rather than raw system resources.

• At 10K users, event handling with Observer can reduce bugs, saving developer time.
• At 1M users, Mediator reduces communication overhead, improving response times by ~20%.
• At 100M users, Chain of Responsibility helps distribute request processing, reducing server load by ~15%.
• Overall, investing in patterns reduces long-term costs by lowering bug rates and improving scalability.

Interview Tip

When discussing behavioral patterns, start by explaining the problem of managing changing behavior and communication.

Then, describe how each pattern solves a specific problem with simple examples.

Finally, relate the pattern choice to system scale and complexity, showing awareness of trade-offs.

Self Check

Your system has growing complexity in handling user actions and events. You notice tight coupling causing bugs. What behavioral pattern do you apply first and why?

Answer: Apply the Mediator pattern to centralize communication and reduce dependencies, improving maintainability and scalability.

Key Result

Behavioral patterns help manage complexity and communication as systems grow, with different patterns suited for different scales and challenges.

Practice

1. Which behavioral pattern is best suited when you want multiple objects to be notified automatically when one object changes its state?

easy

A. Observer pattern

B. Strategy pattern

C. Command pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Understand the need for automatic notifications

   The problem requires multiple objects to be updated when one object changes state, which means a one-to-many dependency.

2. Step 2: Match the pattern to the problem

   The Observer pattern is designed exactly for this: it lets observers subscribe to an object and get notified on changes.

3. Final Answer:

   Observer pattern -> Option A

4. Quick Check:

   Change notification = Observer [OK]

Hint: Notifications to many? Use Observer pattern [OK]

Common Mistakes:

• Confusing Strategy with Observer
• Using Command for notifications
• Choosing Chain of Responsibility for updates

2. Which pattern allows you to change an object's behavior at runtime by switching between different algorithms or strategies?

easy

A. Observer pattern

B. Strategy pattern

C. Command pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Identify the need for interchangeable behaviors

   The question asks about changing behavior dynamically, which means selecting algorithms or methods at runtime.

2. Step 2: Select the pattern that supports behavior switching

   The Strategy pattern encapsulates algorithms and lets you swap them easily without changing the client code.

3. Final Answer:

   Strategy pattern -> Option B

4. Quick Check:

   Change behavior dynamically = Strategy [OK]

Hint: Switch algorithms easily? Use Strategy pattern [OK]

Common Mistakes:

• Mixing Strategy with Observer
• Using Command for behavior changes
• Choosing Chain of Responsibility incorrectly

3. Consider this scenario: You have a request that can be handled by multiple objects in a chain. Each object decides if it can handle the request or passes it on. Which pattern fits this design?
Request -> Handler1 -> Handler2 -> Handler3

medium

A. Command pattern

B. Strategy pattern

C. Observer pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Analyze the request handling flow

   The request passes through a chain of handlers, each deciding to handle or forward it.

2. Step 2: Identify the matching behavioral pattern

   The Chain of Responsibility pattern allows multiple objects to handle a request in sequence until one handles it.

3. Final Answer:

   Chain of Responsibility pattern -> Option D

4. Quick Check:

   Request passes chain = Chain of Responsibility [OK]

Hint: Request passes chain? Use Chain of Responsibility [OK]

Common Mistakes:

• Confusing Chain with Command
• Using Observer for request handling
• Choosing Strategy incorrectly

4. You have a system where commands need to be queued, logged, and executed later. Which behavioral pattern should you use? Identify the error in this choice:
Using Observer pattern to queue commands.

medium

A. Incorrect, use Command pattern instead

B. Incorrect, use Chain of Responsibility instead

C. Incorrect, use Strategy pattern instead

D. Correct use of Observer

Solution

1. Step 1: Understand the requirement for queuing and executing commands

   Queuing, logging, and executing commands later requires encapsulating requests as objects.

2. Step 2: Identify the pattern that encapsulates requests

   The Command pattern encapsulates requests as objects, allowing queuing and deferred execution.

3. Step 3: Identify the error in using Observer

   Observer is for notifications, not for command encapsulation or queuing.

4. Final Answer:

   Incorrect, use Command pattern instead -> Option A

5. Quick Check:

   Queue commands = Command pattern [OK]

Hint: Queue commands? Use Command, not Observer [OK]

Common Mistakes:

• Using Observer for command queuing
• Confusing Command with Strategy
• Choosing Chain of Responsibility wrongly

5. You are designing a notification system where users can subscribe to different event types, and the system should allow adding new event types without changing existing code. Which combination of behavioral patterns is best suited?

hard

A. Chain of Responsibility for subscriptions and Command for event handling

B. Command for subscriptions and Chain of Responsibility for event handling

C. Observer for subscriptions and Strategy for event handling

D. Strategy for subscriptions and Observer for event handling

Solution

1. Step 1: Identify the subscription mechanism

   Users subscribing to events fits the Observer pattern, which supports dynamic subscription and notification.

2. Step 2: Identify flexible event handling

   Strategy pattern allows interchangeable algorithms for handling different event types without changing existing code.

3. Step 3: Combine patterns for extensibility

   Using Observer for subscriptions and Strategy for event handling supports adding new event types easily and keeps code maintainable.

4. Final Answer:

   Observer for subscriptions and Strategy for event handling -> Option C

5. Quick Check:

   Subscribe = Observer, flexible handling = Strategy [OK]

Hint: Subscribe = Observer, flexible handling = Strategy [OK]

Common Mistakes:

• Mixing Command with subscriptions
• Using Chain of Responsibility for subscriptions
• Confusing Strategy with Observer roles