Monolith or microservices

We want to break up the monolith, and it is unclear where to cut

When the choice between a monolith and microservices comes back in every meeting, the pain shows in the code, where a simple feature touches files scattered everywhere, and the reasons lie outside the code too. Domain boundaries were never drawn, teams are split by layer, and releases only go out together. Code and teams mirror each other, which is why splitting the monolith into microservices loosens some knots and tightens others.

Book a call

Does this sound familiar?

  • A feature that is simple to explain needs changes scattered across the whole monolith.
  • Some on the team want microservices and others fear they cannot run them in production, and the discussion stops there.
  • Some services have already been extracted, yet they still release together with the monolith.
  • The same word, such as customer or order, means different things in different parts of the code.
  • Teams are split by technical layer, and every feature needs all of them to coordinate.

Where does the monolith-or-microservices dilemma come from?

The useful question is about boundaries: where they run in the domain, and how far the code and the teams respect them. Each cause below explains why those boundaries are missing today, and the last one reminds you that the slowness may come from somewhere else.

  1. Boundaries drawn on the code, far from the domain

    The cut goes where it looks natural in the code, by table or technical module, and it does not follow the way the business works. The resulting services still depend on one another, and the coupling moves onto the network without shrinking.

  2. A monolith with no boundaries inside it

    A modular monolith, with explicit boundaries between its parts, can hold up well for years, and if one day a part has to be extracted, you can do it without touching the rest. A monolith without those boundaries hurts in many places, and that is where the idea of breaking it up comes from.

  3. Teams organised by technical layer

    When frontend, backend and database belong to different teams, every feature crosses all of them and the software ends up mirroring that division. Splitting the code without redesigning the teams recreates the same handovers between services.

  4. Services that cannot be released on their own

    Each service needs its own pipeline, its own environments and its own monitoring, and without them it ends up shipping in the same release as the others. The main advantage of microservices is releasing one part without waiting for the others, and if services still ship together, all that remains is the cost of complexity.

  5. The bottleneck is elsewhere

    Sometimes the slowness you want to cure with microservices starts somewhere else: waits between teams, manual checks, infrequent releases. If nobody measures where work gets held up, you take on an expensive migration and the problem stays where it was.

What changes when the boundaries are clear

The choice between monolith and microservices becomes a decision to make part by part. Most of the system can stay a modular monolith, and a service is extracted when a context needs independent releases or independent scalability.

Faced with a product request, the team asks which boundary it falls in, and the answer is usually a single boundary. Business and engineering discuss it in the same words, and anyone who wants to extract a service brings a reason everybody can check.

A conversation about your monolith

A recent feature shows where it cuts across the monolith. From there we see whether an EventStorming session to map the domain boundaries is the first step you need.

We use your data to respond to your request. Read our Privacy Policy.