Single responsibility per service in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is single responsibility important in microservices?

Imagine you have a microservice that handles both user authentication and payment processing. What is the main risk of combining these responsibilities in one service?

A It increases the chance of bugs affecting unrelated features and complicates scaling.

B It makes the service easier to maintain and scale independently.

C It reduces network latency between authentication and payment functions.

D It allows the service to use fewer resources by sharing code.

💡 Hint

Think about how mixing different tasks can affect updates and failures.

Combining unrelated responsibilities increases complexity, making the service harder to maintain and scale. Bugs in one area can impact others, violating the single responsibility principle.

❓ Architecture

intermediate

Identifying single responsibility in service design

You are designing a microservice for an online bookstore. Which service design best follows the single responsibility principle?

A A single service that handles all business logic and database access.

B Separate services: one for user accounts, one for orders, and one for inventory management.

C One service for user accounts and orders, another for inventory and shipping.

D A service that manages user accounts, orders, and inventory all together.

💡 Hint

Think about dividing responsibilities so each service does one main job.

Separating user accounts, orders, and inventory into distinct services ensures each service has a clear, focused responsibility, improving maintainability and scalability.

❓ scaling

advanced

Scaling microservices with single responsibility

You have two microservices: Service A handles user profiles, and Service B handles payment processing. Service B experiences high load during sales. What is the best scaling approach?

A Scale both Service A and Service B equally to handle the load.

B Merge Service A and B to share resources and scale together.

C Scale Service A only because user profiles are critical.

D Scale only Service B independently since it has high load.

💡 Hint

Consider which service is under stress and how single responsibility helps.

Because Service B handles payments and faces high load, scaling it independently is efficient. Single responsibility allows scaling only the needed service without affecting others.

❓ tradeoff

advanced

Tradeoffs of strict single responsibility in microservices

What is a potential downside of applying single responsibility too strictly by creating many tiny microservices?

A It can increase communication overhead and operational complexity.

B It simplifies deployment and reduces network calls.

C It eliminates the need for service discovery and load balancing.

D It reduces fault isolation and makes debugging harder.

💡 Hint

Think about what happens when many small services need to talk to each other.

Too many tiny services increase network communication and make managing deployments, monitoring, and debugging more complex.

❓ component

expert

Designing a microservice with single responsibility

You need to design a microservice responsible only for sending email notifications. Which components should this service include to follow single responsibility best?

A Email sending logic, payment processing, and user authentication.

B User management, email template storage, and email sending logic.

C Email sending logic, email template storage, and retry mechanism for failed emails.

D Email sending logic and order processing.

💡 Hint

Focus on components directly related to sending emails.

The service should include email sending, template storage, and retry logic because all relate to the single responsibility of email notifications.

Practice

1. What does the single responsibility principle mean in microservices?

easy

A. Services should be tightly coupled to improve performance.

B. Each service should handle multiple unrelated tasks.

C. Services should share the same database for all tasks.

D. Each service should do only one specific job.

Solution

1. Step 1: Understand the principle meaning

   Single responsibility means one service focuses on one task or job only.

2. Step 2: Evaluate options against this meaning

   Each service should do only one specific job. matches the principle exactly; others contradict it by mixing tasks or coupling.

3. Final Answer:

   Each service should do only one specific job. -> Option D

4. Quick Check:

   Single responsibility = One job per service [OK]

Hint: One service, one job keeps design simple and clear [OK]

Common Mistakes:

• Thinking one service can do many unrelated tasks
• Assuming shared databases mean single responsibility
• Confusing tight coupling with single responsibility

2. Which of the following is the correct way to name a microservice following single responsibility?

easy

A. UserManagementService

B. UserAndOrderService

C. Service123

D. DatabaseService

Solution

1. Step 1: Identify naming that reflects single responsibility

   The service name should clearly indicate one focused responsibility.

2. Step 2: Check options for clarity and focus

   UserManagementService clearly states it manages users only; others mix concerns or are vague.

3. Final Answer:

   UserManagementService -> Option A

4. Quick Check:

   Clear, focused name = single responsibility [OK]

Hint: Service name should reflect one clear job [OK]

Common Mistakes:

• Using vague or numeric names without meaning
• Combining multiple domains in one service name
• Naming services after infrastructure components

3. Given these microservices: UserService handles user data, OrderService handles orders. Which service should handle payment processing?

medium

A. UserService

B. PaymentService

C. OrderService

D. DatabaseService

Solution

1. Step 1: Analyze responsibilities of existing services

   UserService manages users, OrderService manages orders, so payment is a separate concern.

2. Step 2: Assign payment to a dedicated service

   Payment processing is a distinct responsibility, so PaymentService is appropriate.

3. Final Answer:

   PaymentService -> Option B

4. Quick Check:

   Separate payment = separate service [OK]

Hint: Separate distinct jobs into separate services [OK]

Common Mistakes:

• Assigning payment to unrelated services
• Combining payment with user or order logic
• Using generic service names that mix concerns

4. You find a microservice called InventoryAndShippingService causing deployment issues. What is the best fix following single responsibility?

medium

A. Merge it with UserService to reduce services

B. Add more features to InventoryAndShippingService

C. Split it into two services: InventoryService and ShippingService

D. Keep it as is and increase server resources

Solution

1. Step 1: Identify problem with combined responsibilities

   Inventory and shipping are two distinct jobs combined, causing complexity and deployment issues.

2. Step 2: Apply single responsibility by splitting services

   Splitting into InventoryService and ShippingService isolates concerns and simplifies management.

3. Final Answer:

   Split it into two services: InventoryService and ShippingService -> Option C

4. Quick Check:

   Split combined services to fix issues [OK]

Hint: Split combined services to fix complexity [OK]

Common Mistakes:

• Merging unrelated services increases complexity
• Adding features to overloaded services worsens problems
• Ignoring root cause and just adding resources

5. You are designing a microservices system for an online store. Which design best follows single responsibility per service?

hard

A. UserService, ProductService, OrderService, PaymentService, NotificationService

B. StoreService handling users, products, orders, payments, and notifications

C. UserService and OrderService only, handling all tasks

D. One big service for all store functions

Solution

1. Step 1: Understand the scope of each option

   UserService, ProductService, OrderService, PaymentService, NotificationService splits store functions into focused services; others combine many tasks.

2. Step 2: Match design to single responsibility principle

   UserService, ProductService, OrderService, PaymentService, NotificationService clearly assigns one responsibility per service, making it scalable and maintainable.

3. Final Answer:

   UserService, ProductService, OrderService, PaymentService, NotificationService -> Option A

4. Quick Check:

   One service, one job = UserService, ProductService, OrderService, PaymentService, NotificationService [OK]

Hint: Split big tasks into small focused services [OK]

Common Mistakes:

• Combining many tasks into one service
• Using too few services for complex domains
• Ignoring scalability and maintainability