Monoliths vs. Microservices

Overview

A monolith is a single, unified application where all functionality is tightly coupled. Microservices architecture splits functionality into independent, loosely coupled services.

The shift from monoliths to microservices is about team scaling, deployment independence, and technology flexibility, but comes with significant operational complexity.

Key Concepts

Monolith

Single codebase, single deployment unit. All features in one application. Simpler but harder to scale teams.

Microservices

Multiple independent services, each owns its domain. Separate deployments. Complex but enables team autonomy.

Service Boundary

Each microservice has clear responsibility. Communicates via APIs. Owns its database (database per service pattern).

How It Works

Monolith: Single application:

User service code
Product service code
Order service code
Payment service code All deployed together, share database

Microservices: User Service (port 8001) → User DB Product Service (port 8002) → Product DB Order Service (port 8003) → Order DB Payment Service (port 8004) → Payment DB

Each service:

Independent codebase
Independent deployment
Independent scaling
Communicates via HTTP/gRPC/message queues

Use Cases

Monolith: Small teams, startups, simple domains, rapid prototyping

Microservices: Large organizations, complex domains, need independent scaling

Microservices: Multiple teams working simultaneously

Microservices: Different tech stacks for different services

Best Practices

Start with monolith, extract microservices as needed

Define clear service boundaries (domain-driven design)

One database per microservice

Implement API versioning

Use service discovery (Consul, Eureka)

Implement circuit breakers for resilience

Centralized logging and monitoring

Use API gateway for client-facing APIs

Interview Tips

What Interviewers Look For

•
Don't say microservices are always better - discuss trade-offs
•
Mention that monoliths are fine for small teams/startups
•
Discuss when to split: when teams can't work independently
•
Talk about challenges: distributed transactions, data consistency, debugging
•
Mention supporting infrastructure: API gateway, service mesh, distributed tracing
•
Know the "database per service" pattern
•
Discuss the "strangler fig" pattern for migration