Why Single Responsibility Principle in LLD? - Purpose & Use Cases

The Big Idea

What if fixing one bug never broke another part of your system again?

The Scenario

Imagine you are building a simple app where one class handles user data, processes payments, and sends emails all at once.

When something breaks, you have to dig through a big mess of code to find the problem.

The Problem

Doing everything in one place makes the code confusing and hard to fix.

Changing one part can accidentally break another.

It slows down development and causes bugs.

The Solution

The Single Responsibility Principle says each part should do only one job.

This keeps code clean, easy to understand, and safe to change.

Before vs After

✗ Before

class UserManager {
  void saveUser() { /* save user */ }
  void processPayment() { /* payment logic */ }
  void sendEmail() { /* email logic */ }
}

✓ After

class UserRepository {
  void saveUser() { /* save user */ }
}
class PaymentProcessor {
  void processPayment() { /* payment logic */ }
}
class EmailSender {
  void sendEmail() { /* email logic */ }
}

What It Enables

It enables building systems that are easier to maintain, test, and grow without fear of breaking unrelated parts.

Real Life Example

Think of a restaurant kitchen where one chef only makes desserts, another only grills meat, and another handles salads.

This way, each chef masters their task and the kitchen runs smoothly.

Key Takeaways

Each module or class should have one clear responsibility.

Separating concerns reduces bugs and speeds up changes.

Clean design leads to easier teamwork and better software.