We Didn't Remove Complexity. We Moved It.

Microservices didn't kill downtime; they moved in-memory calls onto the network. An honest look at distributed architecture trade-offs and resilience.

• 4 min read • Dan Murphy

Four services, each 99.9% available, chained together in a checkout flow. Your checkout isn't 99.9% available. It's 99.6%, and your yearly downtime just went from roughly nine hours to about thirty-five. That's the trade-off that rarely makes it onto the architecture slide.

To understand why we accepted that trade-off, and when we shouldn't have, you have to look at how enterprise architecture got here: the move from monolithic codebases to containerised microservices.

(Watch the full whiteboard breakdown on YouTube: https://www.youtube.com/watch?v=Boxl4H1sH4M)

Breaking Up the Monolith

Ten to fifteen years ago, the default enterprise application was a tightly coupled monolith. Your user interface, payment processing logic, and inventory management lived in one large codebase, deployed as a single unit and talking to one big SQL database. As traffic grew, this architecture showed two serious weaknesses:

  • Inefficient scaling: To scale the checkout for high traffic, you had to scale everything together. You ran more copies of the entire application behind a load balancer, spending memory and capacity on parts of the app that didn't need scaling at all.
  • Massive blast radius: One bad line of code in a profile picture uploader could cause a memory leak that took down the whole process, payment gateway included, and with it the business.

The Microservices and Container Shift

Many organisations responded by breaking the monolith into smaller, independently deployable services. Today, a user request typically hits an API gateway, which routes it to separate inventory, payment, and shipping services.

Docker made this practical. It packages code, runtime, and dependencies into a standard image, so what runs on a developer's laptop is far closer to what runs in production. It isn't identical: containers share the host's kernel, and CPU architecture differences (ARM vs x86) still bite. But it's close enough to kill most "works on my machine" bugs.

To manage thousands of running containers, Kubernetes became the orchestration engine. If a node dies, Kubernetes detects it and reschedules its workloads onto healthy hardware, typically within minutes. That only works if you've run enough replicas and left headroom to absorb them. Self-healing is something you design for, not something you get for free.

Where the Complexity Went

On paper, this sounds flawless. In enterprise engineering, though, we have to name the failure modes. We didn't remove complexity; we moved it.

  • Network hops: Every network hop is a new chance to fail. If an order must pass through four services, each with 99.9% availability, your total checkout availability drops to 99.6%. That shifts downtime from roughly nine hours a year to about thirty-five.
  • Data consistency: In a monolith, placing an order was one database transaction. Now, handling a case where the card is charged but the inventory service times out requires patterns like sagas (coordinated steps with compensating actions) and idempotency keys (so retries don't charge the customer twice).
  • Observability:A single stack trace becomes distributed tracing across a dozen services. Logging, metrics, and tracing infrastructure is a real line item, in money and in engineering time.
  • Auditability:In regulated industries like banking, you don't just need the transaction to work. You need to prove to a regulator exactly what happened to it. When one customer action touches six services, each with its own logs and data store, reconstructing that trail is a design requirement, not an afterthought.
  • Sometimes the monolith wins: In a 2023 engineering post, Amazon's Prime Video team described moving its audio/video quality-monitoring tool from a distributed serverless design (Step Functions and Lambda) to a single application, cutting infrastructure costs by over 90%. Critics pointed out that this was one service consolidating its internals rather than a retreat from microservices. That's exactly the point: the right granularity depends on the workload.

So When Are Microservices Worth It?

Microservices are a tool for organisational scale as much as technical scale. Conway's Law applies: systems tend to mirror the communication structure of the teams that build them. If you have fifty teams who need to ship independently, microservices are worth the pain.

If you have five engineers and one product, you may just be buying yourself a distributed system to debug at 3 AM. For many teams, the better answer is a modular monolith: one deployable unit with strictly enforced internal boundaries, which you can split later if and when the organisation actually needs it.

What's the worst experience you've had with a legacy monolith? Let's talk about it in the comments.

Recommended Reading:

(Affiliate links)