Skip to content
Technical Judgment

When to Say No to Microservices

The proposal will arrive with a diagram of six boxes and three databases, written by one of your best engineers. Before you evaluate the architecture, check whether your organisation can afford to run it.

Technical JudgmentEngineering Management Academy6 min read

Sooner or later a proposal lands on your desk to split the monolith. It will have a diagram with six boxes, three databases and an API gateway, and it will be written by one of your best engineers. The architecture will probably be sound. The question you have to answer is whether your team, this year, should pay for it.

We think most managers answer that question too late, after the first two services are in production and the cost has become visible. The information needed to answer it earlier is well documented. This post says where to find it and how to use it.

What the proposal will say

A representative version of the case is the DEV Community post by SinghDevHub, Microservices vs Monolithic Architecture: A Practical Approach. It describes a monolith as all functionality in one codebase, an e-commerce backend with orders, products, payments and cart in a single project, and microservices as "separate services that are loosely coupled and work on different ports and with their own database". The monolith is credited with easy testing and straightforward deployment, and its weaknesses are listed as scalability, load balancing and error handling. The microservices version gets a product service in Java on MySQL, a payment service in Node on MongoDB and a shipping service in Python on SQLite.

The post is honest about the machinery this needs, and the honest part is the part to read twice. To make three services work it introduces an API gateway, a service discovery registry, synchronous and asynchronous inter-service communication, circuit breaking, and log aggregation. That is five new systems to operate, each of which can fail on its own, in exchange for the ability to scale the payment service separately from the cart.

AWS's own microservices page lists the benefits in their strongest form, agility, flexible scaling, easy deployment, technological freedom, reusable code and resilience, with each service able to be "developed, deployed, operated, and scaled without affecting the functioning of other services". Every one of those benefits is real. Every one of them is also conditional, and the conditions are the manager's business.

The prerequisites test

Martin Fowler wrote the conditions down in 2014 in Microservice Prerequisites. Before considering the style at all, he says, an organisation needs rapid provisioning, meaning a new server in hours rather than weeks; basic monitoring that will catch technical failures and business ones such as a drop in orders; rapid application deployment through a pipeline that runs in a couple of hours; and a DevOps culture in which developers and operations collaborate closely enough to provision fast and respond to incidents together. His conclusion is unambiguous. Organisations without these capabilities "shouldn't consider using the microservice style".

Turn that into four questions for the author of the proposal, and ask them before you read the diagram.

How long does it take us to stand up a new environment today? If the answer involves a ticket to another team, the answer is no for now.

When the shipping service starts returning errors at two in the morning, what pages whom, and what do they see? If the answer is "we would add monitoring as part of the project", the answer is no for now.

How long is our deployment pipeline, and how often does it run? If a release is a fortnightly event with a change ticket, three services means three fortnightly events.

Who is on call for this today, and who would be on call for six services? If the rota is one person who carries a phone out of goodwill, the proposal is asking that person to carry six phones.

None of these questions is architectural. All of them are the manager's to ask, because the engineer writing the proposal is rarely the person who will pay the cost.

The premium

Fowler's 2015 note on the Microservice Premium is the piece we would hand to anyone who thinks the prerequisites are a formality. Microservices carry a premium, the cost of handling "automated deployment, monitoring, dealing with failure, eventual consistency, and other factors that a distributed system introduces". That premium is paid up front and only recovered when the system is complex enough that a monolith has become hard to manage. His guidance is "don't even consider microservices unless you have a system that's too complex to manage as a monolith", and he names Facebook and Etsy as successful monoliths with continuous delivery, against the claim that microservices are required for it.

The manager's question is whether the pain being described is monolith pain or something else. "Deploys are scary" is usually a test-coverage problem. "Two teams keep conflicting in the same module" is usually a boundaries problem, and boundaries can be fixed inside a monolith first. "We can't scale the image pipeline without scaling everything" is real monolith pain, and it argues for extracting one service rather than six.

Monolith first

Fowler's companion essay, MonolithFirst, makes the strongest practical argument. Almost all the successful microservice systems he had seen "started with a monolith that got too big and was broken up", while nearly all the systems built as microservices from the start had ended up in serious trouble. His explanation is about boundaries. Getting service boundaries right is the central difficulty, it is hard even for experienced architects, and "any refactoring of functionality between services is much harder than it is in a monolith". A monolith lets you move a boundary when you learn it was wrong. A service makes the wrong boundary permanent.

He offers routes a manager can sponsor. Build the monolith with clean module boundaries and separate data so it can be split later. Peel services off the edges while the core stays monolithic. Start with a few coarse services rather than many fine ones. Any of those is a reasonable "yes, but smaller" to the proposal.

How to say no

Say no to the plan rather than the person, and make the no conditional and specific. "Not until our pipeline runs in under an hour and we have a real on-call rota" is a no the engineer can turn into a yes by fixing two things you want fixed anyway. "Extract the image pipeline first, as one service, and we will look at the next one when that has been in production for a quarter" is a no that protects the team and keeps the idea alive.

The refusal to avoid is the vague one. "Let's revisit next quarter" teaches the team that architecture proposals go into a drawer, and the next one will arrive as a fait accompli, with two services already running.

Where this sits in the standard

Evaluating architectural decisions and their organisational consequences is competency TJ-1 in the EMA Competency Framework, in the Technical Judgment domain. The TJ-1 unit of the Body of Knowledge covers how a manager weighs a proposal for trade-offs and reversibility without owning the design, and the SV-4 unit covers total cost of ownership, which is the cost side of the premium.

Filed undermicroservicesarchitecturemonolithtechnical judgmentengineering management
This sits under Technical Judgment in the Competency FrameworkThe Body of Knowledge chapter covers the full set of competencies the examinations assess in this domain.Read it →

Test your judgment, not your recall.

EMA-I is a scenario-based examination in the five domains of the framework. There is no course to buy and no attendance to prove. Sit a sample first, or read what the credential covers.

Keep reading