The microservice tax: what you actually pay after you leave the monolith

The slide says you will pay with “a bit more operational overhead” and buy independent deploys. The invoice is longer. I have left a monolith on purpose, and I have paid the tax. Some of it was worth it. Some of it was us buying a platform company we were not ready to be. This is the bill I would write on the whiteboard before anyone draws the fifth box.

If you are still deciding whether to leave at all, I still start with one deployable and split on a real boundary. This piece is what the split costs after the PR is merged.

You pay in pipelines

One service is one CI. Five services is five CIs, five caches, five “why is this runner out of disk” afternoons, five dependency bumps. Agents will generate the workflow files. They will not sit with the matrix when a base image moves. I have watched a “simple extract” triple our Actions minutes before it saved anyone a release day.

You also pay in the join. A change that used to be one PR is now a contract change, a producer deploy, a consumer deploy, and a week of “which version is in staging.” That join is the tax. Independent deploys are real when the teams are real. When they are the same four people, the join is just a slower monolith.

You pay in local development

The first month after a split, someone will say “just run the stubs.” The second month, a bug will exist only in the join of two real services. The third month, onboarding is a day of compose files and a wiki that is already wrong. I have fixed more “cannot start the app” tickets after a split than I ever fixed in the monolith. That is not a reason never to split. It is a line item. Budget a person to own the happy path to run the system on a laptop, or admit that laptop is gone and you develop in a shared env. Shared envs have their own tax. Pick one and fund it.

You pay in the network, twice

Latency is the obvious tax. A function call becomes a hop. A hop becomes a timeout. A timeout becomes a retry. A retry becomes a double charge if you were sloppy. I have written the idempotency key after the incident, which is the expensive order.

The second network tax is failure modes you did not have. Partial success. Poison messages. A consumer that is down while the producer is fine, so the queue becomes the product. The monolith hid those behind a stack trace. The services make them a design problem. That can be good — you have to be honest. Honesty is work. Work is the tax.

You pay in data

If you did not split the data, you bought a distributed monolith and you will pay migrations across repos. If you did split the data, you bought eventual consistency and you will pay “why is the UI stale.” I prefer the second bill when the boundary is real. I still want someone to own the stale story: a version, a wait, a message. “The other service will catch up” is not a story. It is a shrug.

Transactions that used to be one commit become sagas or outbox tables or “we will reconcile at night.” Nightly reconcile is a product. Put it on the roadmap or do not split the write path.

You pay in on-call

More services means more pages, or the same pages with a worse map. I have been paged into a service I did not know we had because a name was cute and the owner had left. Ownership is the tax you cannot skip. If the extract does not come with a name on the rotation, you did not extract a service. You extracted a landmine.

Dashboards multiply. Tracing becomes mandatory, not nice. I will not run more than two services without a trace I can follow across the hop. The monolith let me grep. Grep does not cross a process unless you paid for the glue.

You pay in a platform, whether you hire one or not

Someone will own CI, deploy, secrets, service discovery, and the way you roll back. If that someone is “the team,” the team has a second product. If you hire a platform person, you are paying a salary so the services stay possible. That salary is often the honest cost of the architecture you wanted. I have seen companies call the salary overhead and the services a win. The win was the salary. The services were the reason they had to pay it.

Shared libraries look like a discount. They are a tax when every service must bump in lockstep. I use them for logging and tracing. I do not use them as a way to pretend we still have one codebase. If the lib is the product, we still have a monolith. We just compile it more times.

You pay in product speed, sometimes

The promise is faster teams. The reality is faster teams when the seams match the teams. When they do not, you pay coordination meetings that used to be a function call. I have sat in those meetings. They feel like architecture. They are the tax arriving as a calendar.

You also pay in “we cannot change the contract this sprint.” Contracts are good. They are also brakes. A monolith lets you change a type and the caller in one PR. That speed is a feature you give up. Give it up when the alternative was a merge queue from hell. Do not give it up so the boxes look independent while the types still move together every week.

You pay in versioning theater

Every hop grows a version. Semver on an internal API is a conversation. Breaking changes become a calendar. I have spent a sprint on “we will support v1 and v2 for a month” that used to be a rename in one repo. Sometimes that month is the point — you bought safety. Sometimes it is fear dressed as compatibility. I ask whether anyone is actually on v1. If the only consumer is us, we are taxing ourselves to look like a vendor.

Schema registries, proto files, OpenAPI gates: all useful, all work. The monolith let the compiler be the registry. You will miss that compiler more than you expect. I miss it when I am tired. I do not miss it when two teams ship on different days and the compiler could not have saved them anyway.

You pay in money that is not glamorous

More services means more idle compute, more load balancers, more log volume, more trace spans you will never read. The cloud bill is a tax that shows up after the architecture review. I have seen a split that was “free” on paper add a four-digit monthly line because we copied production-sized minimums to every box. Right-size is a job. Someone has to do it. If nobody does, the tax compounds in silence until finance asks why the diagram is expensive.

Agents make this worse by being generous with resources in generated manifests. I treat generated YAML as a draft. The draft always asks for more than the old process used. I cut it before I call the extract done.

What the tax is for

I will pay it for a blast radius I can name, a team calendar I can name, or a scale island I can measure. I will not pay it so we can say we left the monolith. Leaving is not a benefit. The benefit is the thing you bought: a deploy that does not wait, a failure that does not take login down, a team that can ship on Tuesday without a billing freeze.

If you cannot say the benefit in one sentence after the extract, you are paying the tax for a story. Stories do not page you. The queue does. I write the benefit on the RFC before I write the service name. If the RFC is “best practice,” I keep the module and I keep the Friday. Best practice is how the tax hides. The invoice is how I make it stand still long enough to decide. I have paid the tax when the sentence was real. I have also paid it when the sentence was “this is what grown companies do.” Grown companies have a platform org and a reason. We had a whiteboard. The whiteboard did not take the page at 3 a.m. I did. That is the last line I want on the invoice before I agree to leave.