Single Responsibility Principle in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identify the Single Responsibility Principle Violation

Which of the following class designs violates the Single Responsibility Principle (SRP)?

A A class dedicated solely to formatting reports.

B A class responsible only for logging system events.

C A class that only manages database connections.

D A class that handles user authentication and also sends email notifications.

💡 Hint

SRP means a class should have only one reason to change.

Option D mixes two responsibilities: authentication and email notifications, violating SRP. Other options have a single responsibility.

❓ Architecture

intermediate

Refactoring for Single Responsibility Principle

You have a class that manages both user data validation and user data storage. How should you refactor it to follow SRP?

A Split the class into two: one for validation and one for storage.

B Keep the class as is but add more methods for other user operations.

C Remove validation and only keep storage in the class.

D Merge the class with another class that handles user interface.

💡 Hint

Think about separating concerns into distinct classes.

Splitting responsibilities into separate classes ensures each class has one reason to change, following SRP.

❓ scaling

advanced

Scaling Impact of Violating Single Responsibility Principle

What is a likely consequence of violating SRP in a large-scale system?

A Faster deployment due to fewer classes.

B Improved modularity and easier testing.

C Changes in one feature cause unexpected bugs in unrelated features.

D Reduced code duplication across modules.

💡 Hint

Consider how tightly coupled responsibilities affect maintenance.

Violating SRP causes classes to have multiple reasons to change, increasing risk of bugs when modifying one feature.

❓ tradeoff

advanced

Tradeoff of Strict Single Responsibility Principle Adherence

What is a potential downside of strictly applying SRP by creating many small classes?

A Increased complexity in managing many small classes.

B Reduced code readability due to fewer classes.

C Higher risk of duplicated code within classes.

D Less flexibility in changing individual components.

💡 Hint

Think about the overhead of many small parts in a system.

While SRP improves modularity, too many small classes can increase complexity in understanding and managing the system.

❓ component

expert

Determining Single Responsibility in a Microservice

A microservice handles user profile updates, notification sending, and analytics tracking. Which change best aligns it with SRP?

A Add caching to the existing microservice to improve performance.

B Split the microservice into three: one for profile updates, one for notifications, and one for analytics.

C Combine this microservice with the authentication microservice for better integration.

D Keep all features but separate them into different methods within the same microservice.

💡 Hint

SRP applies to services as well as classes.

Splitting the microservice by responsibility reduces coupling and aligns with SRP at the service level.