We Had 14 Microservices. We Rebuilt It as a Monolith.
In 2021 we were spending $4,200/month on infrastructure for an app with 800 users. Turns out microservices don't solve problems at your scale — they create them. Here's exactly what broke and what we did about it.
We had 14 microservices for an app with 800 users.
Let that sink in.
It was 2021. My co-founder and I had just raised a small angel round ($180k, enough to feel dangerous) and we'd architected our SaaS tool — a B2B async video feedback platform — like we were Netflix. Auth service. Notification service. Video processing service. A whole-ass API gateway. The works.
We thought we were being smart. We were being idiots.
The month everything caught fire
October 2021. We're at $1,100 MRR. Tiny. And our Datadog bill alone is $380/month. PagerDuty's pinging me at 2am because the notification service can't talk to the user service because something in the message queue got backed up. I'm tracing spans across six different services trying to figure out why a user can't reset their password.
A password reset.
Three hours. That's how long it took to debug a password reset because the failure lived somewhere in the chain between four services and I had to grep logs across all of them to find the one that choked.
Our deploy process was a joke. Updating a shared interface contract meant touching three repos, coordinating two PRs, praying nothing broke in staging, and then doing a carefully sequenced rollout so services didn't get out of sync. For a two-person team. For 800 users.
The thing nobody tells you about microservices
They're not a technical decision. They're an org chart decision.
Conway's Law is real. Microservices make sense when you've got 8 teams who can't step on each other's toes. They're how you scale people, not software. When it's just you and maybe two other devs, you've basically just invented a distributed monolith with all the downsides and none of the benefits.
That works at Google. It does not work for you.
You don't need service isolation. You need to ship the feature your paying customers asked for six weeks ago.
What we actually did
We spent three weeks in November 2021 collapsing everything into a single Rails 7 monolith. Not glamorous. Not a rewrite — we kept almost all the logic, just ripped out the network boundaries.
Here's exactly what we merged: auth, notifications, billing hooks, user management, and the core app API all became modules inside one app. Video processing stayed separate because it genuinely needed to scale independently and run on different hardware. That's it. One legitimate reason to pull something out.
Results after 30 days:
Infrastructure cost dropped from $4,200/month to $900/month. Deploy time went from 22 minutes to 6 minutes. The last PagerDuty alert I got for a cascading service failure was November 14th, 2021. I remember because I threw a small party.
The rule I use now
Don't extract a service until the pain of NOT having it is costing you actual money or actual engineering hours every single week. Not theoretical future pain. Real pain, right now, with receipts.
Until then, a well-structured monolith with clear module boundaries is gonna serve you better than a distributed system you're not staffed to operate.
The architecture astronauts will hate this take. The ones with a product that's actually growing won't.
The best microservice architecture for a two-person startup is a monolith.
Ship the thing. Complicate it later.