A Series B startup. 23 microservices. 10,000 daily active users.
Their AWS bill: $47,000/month.
After consolidating to 4 services: $18,000/month.
That's $348,000 saved per year. Not from clever optimization. Not from better caching. Just from admitting they didn't need microservices.
The Lies We Tell Ourselves
Lie #1: "We Need Microservices to Scale"
Netflix handles 100,000 requests per second. You handle 100.
You're cosplaying as Netflix with 0.1% of their traffic. And paying enterprise prices for startup problems.
Here's the truth: A single m5.xlarge EC2 instance can handle 10,000 requests per second for typical CRUD operations. Cost: $140/month.
Your 23 microservices on t3.medium instances? $1,150/month. For 100 requests per second.
Lie #2: "Microservices Make Development Faster"
20 repositories. 20 CI/CD pipelines. 20 sets of dependencies.
One feature touches 5 services? That's 5 pull requests, 5 code reviews, 5 deployments, 5 places where something can break.
Your "2-day feature" just became a 2-week distributed systems debugging session.
Lie #3: "It's Industry Best Practice"
Best practice for whom? Amazon with 10,000 engineers? Or your 15-person startup?
Amazon created microservices because hundreds of teams were stepping on each other. You created microservices because a Medium article told you to.
Pull up your AWS Cost Explorer. I'll wait.
Now let's find the costs you're not seeing:
Data Transfer: The Silent Killer
Every API call between your services costs money. AWS charges $0.01/GB for cross-AZ transfer.
Let's do kindergarten math:
User request → API Gateway → Service A → Service B → Service C → Database
Each hop: ~10KB request + 50KB response = 60KB
1 million requests/day × 60KB × 5 hops = 300GB/day
Monthly damage: $900 just playing hot potato with your own data
Your monolith? Zero internal transfer costs. Zero.
The Load Balancer Tax
Each microservice needs an Application Load Balancer. AWS charges $0.025/hour + data processing fees.
20 services × $18/month = $360/month
Plus $0.008/GB processed. With 1TB/month per service: another $160.
Total: $520/month for the privilege of having multiple services.
One monolith needs one load balancer. $18/month. Done.
The Observability Black Hole
DataDog charges per host. CloudWatch charges per log group. New Relic charges per service.
Real numbers from a real startup:
DataDog: 20 hosts × $100/month = $2,000
CloudWatch Logs: 20 log groups × 50GB each = $500
CloudWatch Metrics: 200 custom metrics × $0.30 = $60
X-Ray tracing: 10 million traces × $0.000005 = $50
Total: $2,610/month to watch your 20 services do nothing special.
Same app as a monolith: $300/month.
Database Proliferation Disease
The microservices textbook says each service needs its own database.
20 services × RDS t3.small ($35/month) = $700/month
Plus backup storage, plus snapshots, plus read replicas for the important ones.
Real total: $1,400/month.
One RDS t3.xlarge handling everything: $280/month. With better performance.
The NAT Gateway Scam
Your private microservices need internet access. NAT Gateway: $45/month + $0.045/GB.
20 services downloading packages, pulling images, sending webhooks = 2TB/month.
NAT Gateway bill: $135/month.
Monolith in public subnet with security groups: $0/month.
When Microservices Actually Make Sense
Stop defending your architecture. Answer these honestly:
Do you have teams that CANNOT coordinate releases? Not "prefer not to." Not "it's annoying." CANNOT. If your teams can sit in one Zoom call, you don't need microservices.
Do different parts scale at 100x different rates? Not 2x. Not 10x. ONE HUNDRED TIMES. Your user service gets 1,000 req/sec while your PDF generator gets 10? That's 100x. You win. Extract it.
Do you NEED different programming languages? Not want. NEED. Machine learning in Python while everything else is in Java? Fine. Extract just that.
No to all three? You're burning $30,000/month for architectural purity.
The Smart Monolith Pattern
One codebase. Multiple modules. Clear boundaries. No network calls.
app/
├── billing/ # Domain logic
├── users/ # Domain logic
├── notifications/ # Domain logic
├── api/ # HTTP layer
└── shared/ # Common utilitiesEach module has its own:
Domain models
Business logic
Database schema (same database, different schemas)
Tests
What it doesn't have:
Separate repository
Separate CI/CD pipeline
Separate monitoring
Separate deployment
Network calls to other modules
When you hit 10,000 requests per second (you won't), the boundaries are ready. Extract then. Not now.
The Extraction Threshold
Only extract a service when:
It's costing you customers The monolith literally cannot handle the load. Not "might not" in the future. Cannot. Today. Customers are leaving.
It's costing you engineers Teams are blocked weekly because of deployment conflicts. Not occasionally annoyed. Blocked. Weekly. Productivity is measurably dying.
It's costing you compliance PCI DSS requires payment processing isolation. HIPAA requires healthcare data separation. The auditor says "separate system" and means it.
Everything else is resume-driven development.
The Migration Math
Your current setup:
20 microservices
5-person engineering team
100 requests/second peak traffic
$15,000/month infrastructure
After consolidation to 3 services:
API monolith (95% of your logic)
Background jobs (the stuff that actually needs different scaling)
Notifications (the thing that spikes 10x during campaigns)
New costs:
Infrastructure: $4,000/month
Saved: $11,000/month
Annual savings: $132,000
That's two engineers' salaries. Or seed funding runway extension. Or actual features instead of fixing distributed system bugs.
Your Action Items Right Now
Run this query in CloudWatch Insights: Find out how many internal API calls you're making. Multiply by $0.01/GB. Cry.
Count your Load Balancers: Go to EC2 → Load Balancers. Count them. Multiply by $18. That's your ALB tax.
Check your DataDog bill: Settings → Usage → Hosts. How many are just the same app split up?
List services owned by the same team: If the same people own multiple services, why are they separate?
The truth nobody wants to hear: Your startup doesn't need microservices. You need a product that works, customers who pay, and money in the bank.
