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.