Microservices vs Monolith: When Splitting Your App Makes Things Worse

"Software engineering is more than just centering a div." — howtocenterdiv.com

TLDR: You don't need microservices. You need better module boundaries. Split only when teams are truly independent, scaling needs are night-and-day different, or your headcount is pushing 150+. Before any of that — fix the code, draw real boundaries inside the monolith, set up tracing. Microservices don't fix a messy codebase. They just spread it across the network and make it someone else's 3 AM problem. When you do split, use a strangler fig. Not a rewrite. Never a rewrite.

The complaint is usually wrong

OK, so when do they make sense

When domains truly don't touch each other

codeCopy
Payment Service   → invoices, transactions, billing
Content Service   → articles, media, metadata
Auth Service      → sessions, tokens, identity

When scaling needs are completely different

yamlCopy
1services:
2  api:
3    replicas: 3
4    resources:
5      limits:
6        cpus: "0.5"
7        memory: 256M
8
9  transcoder:
10    replicas: 1
11    resources:
12      limits:
13        cpus: "4.0"
14        memory: 8G

When you hit 150+ engineers

Where it gets painful

The network is not your friend

goCopy
1// Monolith. Fast. Simple. Never lies you.
2func GetUserOrder(userID string) (*Order, error) {
3    user := userRepo.Find(userID)
4    order := orderRepo.Latest(user)
5    return order, nil
6}
7
8// Microservices. Now everything can fail.
9func GetUserOrder(userID string) (*Order, error) {
10    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
11    defer cancel()
12
13    user, err := userClient.Find(ctx, userID)
14    if err != nil {
15        return nil, fmt.Errorf("user service down: %w", err)
16    }
17
18    order, err := orderClient.Latest(ctx, user.ID)
19    if err != nil {
20        return nil, fmt.Errorf("order service down: %w", err)
21    }
22
23    return order, nil
24}

One SQL transaction becomes five async steps

sqlCopy
-- Monolith. Atomic. Safe. Boring.
BEGIN;
  UPDATE inventory SET stock = stock - 1 WHERE product_id = 42;
  INSERT INTO orders (user_id, product_id) VALUES (101, 42);
COMMIT;

codeCopy
11. Order Service: create order, status=PENDING
22. Publish: OrderCreated
33. Inventory Service: reserve stock
44. Publish: StockReserved
55. Order Service: status=CONFIRMED
6
7Step 3 fails?
8→ Publish StockFailed
9→ Order Service: cancel order
10→ Hope the compensating transaction doesn't get lost
11→ Hope the queue doesn't drop the message
12→ Good luck

Observability is a week of setup before it's useful

codeCopy
API Gateway → Order Service → User Service → Inventory Service
                                                     ↓
                                           Message Queue
                                                     ↓
                                       Notification Service → Email Provider

Local dev is now a DevOps problem

bashCopy
1# Monolith
2git clone && npm install && npm run dev
3
4# Microservices
5docker-compose up
6# ...2 minutes pass
7# service-a won't start because service-b isn't healthy
8# service-b crashed because the volume mount path is wrong
9# you find the GitHub issue from 2022 — closed, won't fix
10# you spend 45 minutes on setup instead of writing code

The thing nobody talks about: Modular Monolith

codeCopy
1/src
2  /modules
3    /payments
4      payments.controller.ts
5      payments.service.ts
6      payments.repository.ts
7    /inventory
8      inventory.controller.ts
9      inventory.service.ts
10    /notifications
11      notifications.service.ts

typescriptCopy
// This is fine
import { PaymentService } from '@modules/payments';

// This is how you end up with spaghetti
import { calculateTax } from '@modules/payments/utils/tax-calculator';

If you do split, do it slowly

typescriptCopy
1// Before: facade calls in-process module
2class PaymentFacade {
3  constructor(private svc: PaymentService) {}
4
5  async charge(amount: number, customerId: string) {
6    return this.svc.charge(amount, customerId);
7  }
8}
9
10// After: same interface, now calls HTTP
11class PaymentFacade {
12  async charge(amount: number, customerId: string) {
13    const res = await fetch('https://payments.internal/charge', {
14      method: 'POST',
15      body: JSON.stringify({ amount, customerId }),
16    });
17    return res.json();
18  }
19}

The actual decision

codeCopy
11. Can this deploy without coordinating with other teams?
2   NO → don't split.
3
42. Does it have a genuinely different scaling profile?
5   NO → reconsider.
6
73. Do you have distributed tracing and centralized logs running?
8   NO → build that first.
9
104. Does your team have the bandwidth to own this boundary end-to-end?
11   NO → wait.