Why Chain of Responsibility pattern in LLD? - Purpose & Use Cases

The Big Idea

What if your code could pass requests like a relay race, smoothly and without confusion?

The Scenario

Imagine you have a customer support system where every request must be checked by multiple teams one after another. You manually write code that checks each team in order, and if one team can't handle it, you pass it to the next. This quickly becomes messy and hard to manage as teams or rules change.

The Problem

Manually coding each step means lots of repeated if-else checks. It's slow to update because you must change many places. It's easy to make mistakes, like skipping a team or handling requests twice. The code becomes tangled and hard to read, making bugs common and fixing them painful.

The Solution

The Chain of Responsibility pattern lets you link handlers in a chain. Each handler decides if it can process the request or passes it along. This keeps code clean, flexible, and easy to extend. You can add or remove handlers without changing others, making the system scalable and maintainable.

Before vs After

✗ Before

if (teamA.canHandle(request)) {
  teamA.handle(request);
} else if (teamB.canHandle(request)) {
  teamB.handle(request);
} else {
  teamC.handle(request);
}

✓ After

handlerA.setNext(handlerB).setNext(handlerC);
handlerA.handle(request);

What It Enables

This pattern enables building flexible, easy-to-change systems where requests flow smoothly through a chain of handlers without tight coupling.

Real Life Example

In a tech support center, a customer's issue is passed from a basic help desk to specialized teams automatically until someone can solve it, without the customer repeating their problem.

Key Takeaways

Manual checks cause tangled, hard-to-maintain code.

Chain of Responsibility creates a flexible chain of handlers.

It makes adding or changing handlers simple and safe.