Why microservices exist - Design It to Understand It

Design: Microservices Architecture Explanation

Explain the motivation behind microservices, including scalability, deployment, and team organization. Do not cover detailed implementation or specific technologies.

Functional Requirements

FR1: Explain the reasons for adopting microservices architecture

FR2: Highlight the problems microservices solve compared to monolithic systems

FR3: Describe benefits and challenges of microservices

Non-Functional Requirements

NFR1: Use simple language understandable by beginners

NFR2: Focus on realistic scenarios and industry best practices

NFR3: Avoid technical jargon

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

Monolithic application

Microservices as small independent services

API gateways or service communication

Deployment pipelines

Design Patterns

Decomposition by business capability

Independent deployment

Decentralized data management

Service discovery

Reference Architecture

Monolithic App
+---------------------+
|                     |
|  All features tightly|
|  connected in one   |
|  single codebase    |
+---------------------+
           |
           v
Microservices Architecture
+---------+   +---------+   +---------+
| Service |   | Service |   | Service |
|   A     |   |   B     |   |   C     |
+---------+   +---------+   +---------+
      \           |           /
       \          |          /
        +-------------------+
        |   API Gateway     |
        +-------------------+

Components

Monolithic Application

Any programming language

Single large application with all features tightly coupled

Microservices

Multiple independent services

Divide application into small, focused services each handling a specific business function

API Gateway

HTTP reverse proxy or API management tool

Route client requests to appropriate microservices and handle cross-cutting concerns

Request Flow

1. In monolithic app, all features run in one process and share the same database.

2. Scaling requires scaling the entire app even if only one feature needs more resources.

3. Deploying new features requires redeploying the whole app, risking downtime.

4. Microservices split features into separate services that run independently.

5. Each service can be developed, deployed, and scaled separately.

6. API Gateway routes requests from clients to the correct microservice.

7. Teams can own different services, improving development speed and ownership.

Database Schema

In monolithic: Single database shared by all features. In microservices: Each service may have its own database to ensure independence and avoid tight coupling.

Scaling Discussion

Bottlenecks

Monolithic app becomes hard to scale and maintain as it grows.

Tight coupling causes deployment risks and slows down development.

Microservices introduce complexity in communication and data consistency.

Solutions

Use microservices to isolate features and scale only what is needed.

Implement API Gateway to manage service communication.

Adopt DevOps practices for continuous deployment.

Use asynchronous messaging to reduce tight coupling.

Implement monitoring and logging to handle distributed system complexity.

Interview Tips

Time: Spend 10 minutes explaining monolithic challenges, 15 minutes on microservices benefits and trade-offs, 5 minutes on scaling and organizational impact, 15 minutes for questions and discussion.

Monolithic apps are simple but hard to scale and deploy as they grow.

Microservices break down the app into smaller, manageable pieces.

They allow independent development, deployment, and scaling.

Microservices require good communication and monitoring strategies.

Trade-offs include increased complexity and operational overhead.

Practice

1. Why do organizations choose microservices over a single large application?

easy

A. To write all code in one programming language

B. To make the system run only on one server

C. To avoid using any databases

D. To break a big system into smaller, manageable parts

Solution

1. Step 1: Understand the problem with large applications

   Large applications are hard to manage, update, and scale because everything is tightly connected.

2. Step 2: Identify microservices benefit

   Microservices split the big system into smaller parts that can be managed and updated independently.

3. Final Answer:

   To break a big system into smaller, manageable parts -> Option D

4. Quick Check:

   Microservices = smaller parts [OK]

Hint: Microservices split big apps into small parts [OK]

Common Mistakes:

• Thinking microservices run only on one server
• Believing microservices avoid databases
• Assuming microservices require one language

2. Which of the following is a key feature of microservices architecture?

easy

A. All services share the same database schema

B. Each service can be developed and deployed independently

C. Services must be written in the same programming language

D. Microservices require a monolithic deployment

Solution

1. Step 1: Review microservices independence

   Microservices allow teams to develop and deploy each service without affecting others.

2. Step 2: Check other options

   Sharing the same database or language is not required; monolithic deployment contradicts microservices.

3. Final Answer:

   Each service can be developed and deployed independently -> Option B

4. Quick Check:

   Independent deployment = microservices [OK]

Hint: Microservices = independent deploys [OK]

Common Mistakes:

• Assuming all services share one database
• Believing all code must be in one language
• Thinking microservices deploy as one unit

3. Consider a system split into microservices: User Service, Order Service, and Payment Service. If the Order Service crashes, what is the likely impact on the User Service?

medium

A. User Service continues working independently

B. User Service will lose all user data

C. User Service will also crash immediately

D. User Service will restart automatically

Solution

1. Step 1: Understand microservices isolation

   Each microservice runs independently, so failure in one does not crash others.

2. Step 2: Analyze impact on User Service

   User Service can keep working even if Order Service crashes, though some features may be limited.

3. Final Answer:

   User Service continues working independently -> Option A

4. Quick Check:

   Microservices isolation = independent operation [OK]

Hint: Microservices fail independently, not together [OK]

Common Mistakes:

• Assuming one service crash crashes all
• Thinking user data is lost when order fails
• Believing services auto-restart always

4. A team built a microservices system but notices that deploying one service requires stopping the entire system. What is the likely mistake?

medium

A. Services are tightly coupled and not independent

B. They are using too many programming languages

C. The database is too large

D. They did not write enough tests

Solution

1. Step 1: Identify deployment problem

   If deploying one service stops the whole system, services are not independent as microservices require.

2. Step 2: Rule out other options

   Programming languages, database size, or tests do not cause deployment to stop all services.

3. Final Answer:

   Services are tightly coupled and not independent -> Option A

4. Quick Check:

   Independent services = independent deploys [OK]

Hint: Independent deploy means no system-wide stop [OK]

Common Mistakes:

• Blaming programming languages for deployment issues
• Thinking database size causes deployment stop
• Assuming tests affect deployment independence

5. A company wants to scale their online store quickly during sales. How does microservices architecture help achieve this?

hard

A. By forcing all services to scale together as one unit

B. By allowing only the payment service to scale independently

C. By enabling each service to scale based on its own demand

D. By removing the need for any scaling

Solution

1. Step 1: Understand scaling in microservices

   Microservices let each part of the system scale separately depending on its load.

2. Step 2: Apply to online store scenario

   During sales, services like Order or Payment can scale more without scaling unrelated services.

3. Final Answer:

   By enabling each service to scale based on its own demand -> Option C

4. Quick Check:

   Microservices scale independently = efficient scaling [OK]

Hint: Scale each service separately for efficiency [OK]

Common Mistakes:

• Thinking only one service scales
• Believing all services must scale together
• Assuming microservices remove scaling needs