- Market
- Saudi Arabia
- Written for
- CTO, CIO
- Decision
- Decide between a monolith and microservices for a new system
The unfashionable answer
Why a well-built monolith is the right start for most systems
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
A monolith is a single deployable application, and for a small number of teams that is an advantage rather than a limitation. A function call is faster and more reliable than a network call, a change that spans two parts of the system is one commit and one deploy, and a failure is a stack trace rather than a distributed-tracing investigation across five services. The reason microservices exist is not that they are technically superior; it is that they let independent teams release without coordinating, which is a problem you only have once you have several teams.
The trap is treating microservices as the grown-up choice and the monolith as something to escape. A single team that splits early inherits every operational cost of a distributed system — service discovery, network failure handling, data spread across stores that cannot share a transaction, deployment orchestration — and none of the organisational benefit, because there is still only one team doing the coordinating, now across a network instead of within a codebase. The honest sequence is a monolith with clean internal boundaries first, and extraction later, along a boundary that has already proven itself.
The trade
What each architecture costs, and what it actually buys
The comparison that matters is not scalability — both can scale. It is where the complexity goes and what the architecture demands of the people who run it.
| Option | What you deploy | Where the complexity lives | How a failure spreads | What it demands of the team | Best for |
|---|---|---|---|---|---|
| Monolith | One application, deployed as a unit. A change anywhere goes out together, which is simple but couples everyone's releases to one pipeline. | Inside the code, as module boundaries. Discipline is enforced by review, not by the network, which is cheaper but easier to erode. | A bad deploy or a memory leak can take the whole application down, so the blast radius is the system. | One codebase to understand and one runtime to operate. Onboarding is faster and the operational surface is small. | One to a few teams, an early product, or any system whose boundaries are not yet stable enough to draw a service line through. |
| Microservices | Many services, each deployed on its own, so a team can release its part without waiting — the benefit the whole architecture exists for. | In the spaces between services: the network, the contracts, the data that no longer shares a transaction, the orchestration. | One service can fail without the others, if — and only if — every caller was built to tolerate it. Otherwise a failure cascades. | Distributed-systems skills, mature deployment and observability, and the headcount to own several services. Real, ongoing operational cost. | Several independent teams that keep colliding in one codebase, or a proven boundary with genuinely different scaling or reliability needs. |
When it is time
The signals that actually justify pulling a service out
Extract for a reason you can name, not because the codebase feels large. Each of these points to a specific boundary rather than a wholesale split.
Teams blocking each other on one pipeline
Independent teams waiting on a shared release is the original problem microservices solve — an organisational signal, not a technical one.
What to extract first: The part one team owns end to end and would release on its own cadence.
One component scales unlike the rest
When one function needs far more compute, or spikes on a different schedule, scaling the whole monolith to serve it is wasteful.
What to extract first: The heavy or bursty component, so it can scale on its own terms.
A part has stricter reliability needs
A payment or safety path that must stay up while the rest can degrade is a case for isolating it behind its own failure boundary.
What to extract first: The critical path, isolated so a failure elsewhere cannot take it down.
A boundary has stayed stable for a long time
A module whose interface has not churned is safe to split; a boundary still moving will make the network contract churn with it, which is the expensive kind of change.
What to extract first: The settled module, extracted along the interface it already has.
Our role
How we build a monolith that is ready to be split later
- 01
Boundaries from the start
We build the monolith in modules with clean interfaces between them, so the seams a service would later be extracted along already exist — the cheap insurance that makes a future split a refactor rather than a rewrite.
- 02
Split only when it is earned
We extract a service when a boundary shows one of the real signals — a team, a scaling need, a reliability line — and we say so when none of them is present, because splitting on schedule rather than on evidence is how the cost arrives without the benefit.
- 03
Consolidation when it is right
Where a system has already been over-split and the network between services is now the source of the pain, we merge services back toward a maintainable core — the direction few suppliers will recommend because it undoes work they might have sold.
How many teams will own this system, and where its real reliability and scaling lines fall, are yours to know; we build so the monolith is easy to split when one of those makes the case, and we do not split it before one does.
Common questions
What buyers ask
Won't a monolith just turn into a big ball of mud over time?+
Only if its internal boundaries are not maintained, and the same discipline failure produces a distributed ball of mud in microservices — with the added cost that the mess is now spread across a network. A monolith with enforced module boundaries stays reasonable for a long time; what turns it into mud is skipping the boundaries because a function call lets you skip them. Microservices force the boundaries by making a shortcut a network call, but they charge the full operational price of a distributed system for that enforcement. Discipline is cheaper than distribution.
Every engineer we interview expects microservices. Is a monolith a hard sell internally?+
Sometimes, and the answer is to be precise about the word. A modular monolith is not the tangled single tier that gave monoliths their reputation; it has the same internal boundaries a microservice architecture has, without the network between them. Framed that way, most experienced engineers agree — the credible ones have seen a premature split cost more than it saved. What helps is committing in writing to the signals that would trigger extraction, so the team knows the monolith is a deliberate starting point with a defined path to services, not a refusal to ever split.
We already run microservices and they hurt. Can you merge some back?+
Yes, and it is a legitimate direction that too few suppliers will suggest. Over-splitting shows up as a change that needs three services deployed in order, a request that fans out into a dozen network calls, and a team that spends more time on the plumbing between services than on the services. Where two services are always deployed together and always change together, they were one service drawn as two, and merging them removes a network boundary that bought nothing. We do it incrementally, collapsing the boundaries that carry cost without carrying independence, and keep the ones that a real team or a real reliability line justifies.
In this cluster
A short architecture review that says whether your system has an organisational reason to split at all, and if so which boundary to extract first rather than dividing everything.
Right-size the architecture
