New technologies

Microservices or monolith: which architecture for your app?

Microservices vs monolith: what each really costs, why a modular monolith is often the better start, the signs it is time to split, and a decision checklist.

You are planning a new application, or your current one is starting to creak, and someone on the team says the word: microservices. The microservices vs monolith debate often sounds like a matter of taste, yet it mostly comes down to team size, operations and how often your business changes. In this article, we explain what each architecture really means, the costs of microservices that rarely appear on the slides, why a modular monolith is often the better place to start, and the signs that it is time to split, with a decision checklist for your next architecture meeting.

What a monolith and microservices really mean

The monolith

A monolith is one application, built and deployed as a single unit. The screens, the business rules and the access to the data live in the same codebase and usually share one database. One build, one deployment, one place to look when something goes wrong.

“Monolith” is not an insult. Most business software starts this way and serves its users for years. The trouble starts when the inside has no structure: every part reaches into every other part, and a change to invoicing breaks the customer list. That is a design problem, not a monolith problem.

Microservices

Microservices split the application into small services, each owning one business capability (orders, billing, notifications) and its own data. They talk to each other over the network, through APIs (application programming interfaces) or messages, and each one can be deployed on its own, often by its own team.

The promise is real: teams that move independently, parts that scale separately, a failure that stays inside one service. Each benefit has a price, paid in operations and coordination.

The modular monolith, in between

A modular monolith is still one deployable application, but inside, it is divided into modules with clear boundaries. Each module owns its tables, exposes a small public interface and never touches another module’s internals. You get most of the clarity of microservices without a network between the parts.

The hidden costs of microservices

Microservices move complexity out of the code and into the space between services. That complexity does not disappear: it changes owner.

Operations

Each service needs its own build, deployment pipeline, configuration and secrets, and often its own database. Ten services means ten of everything to patch, upgrade and keep consistent. Without solid automation (containers, infrastructure as code, continuous integration and delivery), the team spends its days running the platform instead of building the product.

Monitoring and debugging

In a monolith, an error comes with a stack trace. Across services, one customer action can cross five of them, and finding out why it failed requires centralised logs, metrics and distributed tracing. Someone must set these tools up, pay for them and read them. Those logs and metrics also add to the monthly hosting bill, one of the items covered in our guide to keeping cloud costs under control.

Data consistency

When each service owns its data, a simple database transaction becomes a conversation. An order is accepted, then the payment fails: who cancels what, and in which order? You need patterns such as sagas, retries and messages that can safely be processed twice, and you accept that some data is only consistent after a short delay.

Team size and skills

Microservices work best when each service has a team that owns it from end to end. With four developers and twelve services, everyone owns everything. Conway’s law says that systems mirror how the organisations that build them communicate: the architecture should fit the team you actually have.

Illustrative example (fictitious figures)

A SaaS start-up with 5 developers considers splitting its product into 8 services.

What to look after Modular monolith 8 microservices
Deployable units 1 8
Build and deployment pipelines 1 8
Databases to back up and migrate 1 up to 8
Network calls between parts none dozens, each able to fail

That is more than one service per developer, on top of the features customers are waiting for.

Why a modular monolith is often the better start

For most new products, and for most business applications in SMEs, we recommend starting with a modular monolith, for three reasons.

You do not yet know where the boundaries are. Early on, your understanding of the business changes every month. Drawing service boundaries too soon freezes guesses into network contracts. Moving code between modules is a refactoring; moving it between services is a migration.

Speed matters most at the start. One codebase, one deployment and one database let a small team deliver and correct quickly, which is exactly what a first release needs, as our guide to launching a SaaS MVP explains.

It keeps the door open. If each module has its own data and a small interface, extracting one later as a service is a contained piece of work, not a rewrite.

In practice, a monolith is “modular” when:

  • each business capability has its own folder or package, with its own tables;
  • other modules call it only through its public interface;
  • automated checks refuse forbidden dependencies between modules.

This is how we approach SaaS products and custom applications. Still, neither architecture is always right: a modular monolith is a sensible default, not a dogma.

Microservices vs monolith: a decision checklist

The more “yes” answers, the stronger the case for splitting at least part of the application.

  1. Do several teams (not just several developers) block each other when they deploy?
  2. Does one part carry a very different load from the rest?
  3. Does one part need a different technology, release rhythm or security level?
  4. Are the business boundaries stable and well understood?
  5. Do you already have automated builds, tests and deployments, plus centralised logs?
  6. Is someone ready to own the platform: hosting, monitoring, incidents?
  7. Can the business accept that some data becomes consistent a few seconds later?

If you answered “no” to questions 5 to 7, start with, or stay on, a modular monolith: the foundations are not there yet.

When to use microservices: the signs it is time to split

The signs

  • Deployments have become a queue: teams wait for each other, and a small fix waits for a large release.
  • One component needs to scale on its own, and scaling the whole application for it costs too much.
  • A part has a life of its own: a different team, technology or regulatory constraint.

Notice what is not on the list: “the code is messy”. A messy monolith split into services becomes messy distributed code. Clean up the boundaries first, as we describe in our article on technical debt and modernisation.

How to split without a big bang

  1. Pick one module with clear boundaries and a concrete reason to leave: load, team or technology.
  2. Put the automation in place first: pipeline, monitoring, tracing. The work at Orange Business Services led by our founder, Anass Chabbab, in his previous roles included continuous integration with Jenkins and SonarQube, and Banque Populaire workstations set up in one click instead of half a day. That kind of automation is the ground several services stand on.
  3. Extract the module behind its existing interface, so the rest of the application barely notices. The “strangler” approach moves calls from the old code to the new service gradually.
  4. Check that behaviour has not changed, with tests that run against both versions, as our article on parity testing explains.
  5. Measure, then decide on the next one.

The same caution applies when installed software becomes a SaaS: moving installed software to SaaS is a big enough change without splitting into services at the same time.

Frequently asked questions

Is a monolith a bad software architecture?

No. A monolith is one deployable application, and that is often an advantage: simpler hosting, easier debugging, transactions that just work. What hurts is a monolith without internal structure, where every part depends on every other. The real question is whether the boundaries are clear and whether anyone needs to deploy parts separately.

When to use microservices?

When several teams need to deploy independently, when one part has a very different load or technical needs, and when you already have the automation and monitoring to run several services. Microservices solve organisational and scaling problems; they rarely help a small team deliver faster. If your problem is code quality, fix the structure inside the application first.

Can we move from a monolith to microservices later?

Yes, and it is usually the safest path. If the monolith is modular, each module already has its own data and interface, so extracting it is a contained project. Go one module at a time, keep old and new behind the same interface, and check that behaviour is unchanged before switching over.

In short

Microservices vs monolith is a question of team, operations and data, not fashion. Microservices bring independent deployments and separate scaling, at the price of more pipelines, more monitoring, network failures and delayed consistency. For most new products and SME applications, a modular monolith is the better start: quick to build, simple to run, and ready to split one module at a time when real signs appear.

Wondering whether your application should stay in one piece or be split? Book a free 30-minute discovery call: we look at your application and your team together, and tell you honestly whether splitting is worth it.

Related servicesSaaS productsCustom softwareModernisation

Have a project in mind?

Let’s talk about it on a 30-minute discovery call, free and with no obligation.

Book a discovery call

Further reading

All articles