When to use microservices (and when not to) - System Design Guide

Problem Statement

Monolithic applications become hard to maintain and scale as they grow. When many teams work on the same codebase, changes can cause unexpected bugs and slow down releases. Also, scaling the entire app for a small part that needs more resources wastes effort and money.

Solution

Microservices break the application into small, independent services that focus on specific business functions. Each service can be developed, deployed, and scaled separately, allowing teams to work independently and scale only what is needed. This reduces complexity and improves fault isolation.

Architecture

Service A

→Service B

↓

Database A

This diagram shows independent microservices communicating with each other and managing their own databases, illustrating separation and independent scaling.

Trade-offs

✓ Pros

→

Enables independent development and deployment by different teams.

→

Improves fault isolation; failure in one service doesn't crash the whole system.

→

Allows scaling only the services that need more resources, saving costs.

→

Supports technology diversity; teams can choose the best tools per service.

✗ Cons

→

Increases operational complexity with many services to monitor and manage.

→

Requires robust inter-service communication and data consistency handling.

→

Can lead to duplicated effort and data if not carefully designed.

Use microservices when your application has multiple distinct business domains, requires independent scaling, or when multiple teams need to work in parallel without blocking each other. Typically beneficial when user traffic exceeds thousands of requests per second or when deployment speed and fault isolation are critical.

Avoid microservices if your application is small, simple, or has a single team managing it. If your traffic is low (under a few hundred requests per second) or you need rapid initial development, the overhead of microservices can slow you down and add unnecessary complexity.

Real World Examples

Netflix

Split their streaming platform into microservices to allow independent scaling and rapid deployment of new features without downtime.

Amazon

Decomposed their monolithic retail platform into microservices to enable teams to innovate independently and scale services like search and recommendations separately.

Uber

Uses microservices to handle different domains like trip management, payments, and user profiles, allowing fault isolation and independent scaling.

Alternatives

Monolithic Architecture

All functionality is built into a single deployable unit without service boundaries.

Use when: Choose monolith when the application is small, teams are small, and rapid initial development is needed.

Modular Monolith

Application is a single deployable unit but internally organized into clear modules with strict boundaries.

Use when: Choose modular monolith when you want clear code separation without the operational complexity of microservices.

Serverless Architecture

Breaks functionality into small functions triggered by events, abstracting server management.

Use when: Choose serverless when you have event-driven workloads with unpredictable traffic and want to minimize infrastructure management.

Summary

Microservices break large applications into smaller, independent services to improve scalability and team autonomy.

They add operational complexity and require careful design of communication and data management.

Use microservices when your system is large, complex, or needs independent scaling; avoid them for small or simple apps.

Practice

1. Which scenario is best suited for using microservices architecture?

easy

A. A large, complex application requiring independent scaling of components

B. A simple, single-function app with a small user base

C. A small script running on a single machine

D. A static website with no backend logic

Solution

1. Step 1: Understand microservices purpose

   Microservices are designed for complex apps where parts can scale or update independently.

2. Step 2: Match scenario to microservices benefits

   A large app needing flexibility and scaling fits microservices well; small or simple apps do not.

3. Final Answer:

   A large, complex application requiring independent scaling of components -> Option A

4. Quick Check:

   Complex app = microservices [OK]

Hint: Use microservices only for complex, scalable apps [OK]

Common Mistakes:

• Choosing microservices for small or simple apps
• Ignoring team size and management overhead
• Assuming microservices always improve performance

2. Which of the following is a correct reason NOT to use microservices?

easy

A. The app requires frequent updates to parts

B. The application is very small and simple

C. The app needs to scale independently

D. The app has multiple teams working on different features

Solution

1. Step 1: Identify when microservices are unnecessary

   Microservices add complexity and overhead, so small simple apps don't benefit.

2. Step 2: Evaluate options

   Options A, B, and D are reasons to use microservices, not avoid them.

3. Final Answer:

   The application is very small and simple -> Option B

4. Quick Check:

   Small app = avoid microservices [OK]

Hint: Avoid microservices for small, simple apps [OK]

Common Mistakes:

• Confusing scaling needs as a reason to avoid microservices
• Ignoring complexity added by microservices
• Assuming microservices fit all team sizes

3. Consider a microservices app with 5 services. If each service requires 2 developers and the team has only 6 developers total, what is the likely outcome?

medium

A. The team can easily manage all services independently

B. The services will merge into a monolith automatically

C. The team will struggle due to insufficient resources for each service

D. The app will automatically scale without developer input

Solution

1. Step 1: Calculate developer needs

   5 services x 2 developers each = 10 developers needed.

2. Step 2: Compare with available team size

   Only 6 developers are available, which is less than 10, causing resource strain.

3. Final Answer:

   The team will struggle due to insufficient resources for each service -> Option C

4. Quick Check:

   Dev shortage = struggle managing microservices [OK]

Hint: Check if team size matches microservices needs [OK]

Common Mistakes:

• Assuming microservices scale developer needs automatically
• Ignoring team size constraints
• Thinking services merge automatically without effort

4. A team tries to convert a small monolithic app into microservices but faces deployment failures and communication errors. What is the most likely cause?

medium

A. Microservices do not support deployment automation

B. The app was too large for microservices

C. They used too many developers

D. They underestimated the complexity of managing microservices

Solution

1. Step 1: Analyze the problem context

   Small apps converted to microservices often face complexity in communication and deployment.

2. Step 2: Identify the cause

   Deployment failures and communication errors usually come from underestimating microservices management overhead.

3. Final Answer:

   They underestimated the complexity of managing microservices -> Option D

4. Quick Check:

   Underestimating complexity = deployment issues [OK]

Hint: Expect extra management work with microservices [OK]

Common Mistakes:

• Blaming microservices for deployment automation lack
• Assuming more developers cause deployment errors
• Thinking large apps cause these specific errors

5. A startup with a small team plans to build a new app. They want to decide between microservices and a monolithic design. Which approach should they choose and why?

hard

A. Start with a monolith to reduce complexity and switch later if needed

B. Start with microservices to prepare for future scaling immediately

C. Use microservices only if the app is a static website

D. Avoid both and build multiple separate apps

Solution

1. Step 1: Consider team size and app complexity

   A small team benefits from simpler monolithic design to reduce overhead and speed development.

2. Step 2: Plan for future growth

   Starting monolithic allows easier initial development; microservices can be adopted later if scaling is needed.

3. Final Answer:

   Start with a monolith to reduce complexity and switch later if needed -> Option A

4. Quick Check:

   Small team = start monolith [OK]

Hint: Small teams start monolith, scale to microservices later [OK]

Common Mistakes:

• Choosing microservices too early for small teams
• Confusing static websites with microservices use
• Ignoring future scalability planning