Microservices vs Monolith: A Decision Framework

The Hype Problem

"Netflix uses microservices" is not a reason to use microservices. Netflix has 12,000+ engineers. Your team has 5.

Start with the Monolith

A well-structured monolith serves most teams until they hit ~50 engineers or have very specific scaling needs.

my-app/
├── src/
│   ├── modules/
│   │   ├── auth/
│   │   │   ├── auth.controller.ts
│   │   │   ├── auth.service.ts
│   │   │   └── auth.types.ts
│   │   ├── posts/
│   │   │   ├── posts.controller.ts
│   │   │   ├── posts.service.ts
│   │   │   └── posts.types.ts
│   │   └── billing/
│   ├── shared/
│   └── infrastructure/

When Microservices Make Sense

✅ You need:

• Independent scaling (search handles 100x more traffic than billing)
• Independent deployment (team A ships without waiting for team B)
• Different tech stacks per service (ML team uses Python, API team uses Node)
• Fault isolation (billing failure shouldn't take down the blog)

❌ You DON'T need microservices for:

• "Clean architecture" — That's about code structure, not deployment
• "Scalability" — A monolith on modern hardware handles enormous load
• "Team autonomy" — Module boundaries in a monolith achieve this too

The Costs of Microservices

What you take on:

• Network latency — Every service call adds 1-50ms
• Data consistency — No more ACID transactions across services
• Operational complexity — Service discovery, load balancing, tracing
• Debugging difficulty — Requests span multiple services and logs
• Deployment coordination — API contracts between services

The Decision Matrix

The Middle Ground: Modular Monolith

Structure your monolith with clear module boundaries:

// modules/posts/posts.service.ts
// This module only imports from its own directory and shared/
// It communicates with other modules via defined interfaces

import type { AuthService } from '../auth/auth.interface'

export class PostsService {
  constructor(private auth: AuthService) {}

  async createPost(userId: string, input: CreatePostInput) {
    const user = await this.auth.getUser(userId)
    // ...
  }
}

When (if) you need to extract a service later, the boundaries are already clean.

Start with the simplest architecture that could work. Extract services when you have evidence you need them.