Skip to content

Published

Reading time5 min

AuthorMarc Ariel Oka

Monolith or Microservices: What a Small Business Should Really Choose

Microservices are the stuff of dreams. But even Amazon and Shopify have chosen monolith for some systems. Here’s how to decide without following fashion.

At the start of a project, one question keeps coming up: « Should we go with microservices, like Netflix? »

It’s a fair question. But Netflix has thousands of engineers and hundreds of millions of users. Your small business may have three developers and a few thousand customers. Copying a giant’s architecture is a bit like buying a bus to commute alone: it runs, but it’s expensive to maintain.

So, monolith or microservices? Here’s how I see it, along with what the big companies have learned themselves.

The three options, in plain words

The monolith: the whole application is a single program, deployed in one piece, with a single database. It’s the starting point of most Laravel, Rails or Django projects.

Microservices: the application is split into small independent services (billing, payments, notifications…), each with its own database, talking to each other over the network.

The modular monolith: a single program, but organised into business modules with strict boundaries. Each module owns its data and can only be reached through a clear interface.

Classic monolith Modular monolith Microservices
Deployment One One One per service
Speed at the start Very fast Fast Slow
Infrastructure cost Low Low High
DevOps skills needed Basic Basic Advanced
Main risk Tangled code as it grows Discipline to maintain Network and data complexity
Best for Prototype, small team Small business, growing startup Large independent teams

What the big companies learned

Martin Fowler, 2015. One of the authors who popularised microservices makes a simple observation: almost all successful microservice stories started with a monolith that got too big and was broken up. Conversely, systems built as microservices from day one almost always end up in serious trouble.

Shopify, 2019. Over 1,000 developers work on the same Ruby on Rails codebase. When it became hard to manage, Shopify didn’t rush to microservices. The team judged they would solve some problems but create others: more pipelines to maintain, latency on every network call, data harder to get at. They chose a modular monolith, split by business domain (orders, shipping, billing), with a tool that blocks forbidden calls between modules.

Amazon Prime Video, 2023. The team monitoring video stream quality merged its distributed components into a single process. Reported result: over 90% savings on that tool’s infrastructure, and better ability to scale.

Be careful not to over-generalise. This is one tool, not Prime Video’s entire architecture. And microservices remain relevant when an organisation has many teams that each need to ship independently. The lesson is that architecture is chosen to fit the problem, not the trend.

How to choose: five questions to ask

  1. How many developers will work on it? Microservices first solve an organisational problem: letting several teams ship without stepping on each other’s toes. With a team of three, that problem doesn’t exist.
  2. Does one part of the system have very different needs? For example, heavy image processing while the rest of the app is lightweight. That’s often the only good reason to pull a piece out.
  3. Do you have the DevOps skills? With microservices, you deploy, monitor and debug dozens of moving parts. Without solid continuous integration, centralised logs and request tracing, every bug becomes an investigation.
  4. Is your business domain already stable? Splitting too early means freezing boundaries you don’t understand well yet. Moving them later costs far more between two services than between two folders.
  5. What’s your infrastructure budget? Each service has its own server or container, database and monitoring. The bill climbs fast.

My recommendation for a small business or startup

Start with a modular monolith. You keep the simplicity of a single deployment, and you prepare for what comes next.

In practice, on a Laravel project, I organise the code by business domain rather than by file type:

app/
└── Modules/
    ├── Billing/
    │   ├── Models/
    │   ├── Actions/
    │   ├── Events/
    │   └── BillingService.php   ← the only way in
    ├── Customers/
    └── Payments/

Four rules are enough to make it hold over time:

  • Each module owns its tables. The Payments module never reads Billing’s tables directly: it goes through the Billing service.
  • Modules communicate through interfaces or events. For example, Payments publishes « PaymentReceived », and Billing marks the invoice as paid.
  • Boundaries are checked automatically. An architecture test (with Pest, for example) fails if a module imports another module’s internal code.
  • A service is only extracted for a real reason. A heavy workload (document processing, bulk messaging) can move to a separate service or worker the day it slows everything else down. Thanks to the boundaries already in place, the extraction is simple.

This approach keeps every door open. If your business takes off tomorrow and the team grows to thirty developers, each module can become a microservice without rewriting everything.

In short

Microservices are not a higher level. They’re an answer to a specific problem: many teams that each need to ship on their own. If you don’t have that problem yet, you pay the price of the solution without getting its benefits.

A well-organised monolith is not old-fashioned. It’s often the most mature choice.

Unsure about the architecture of your next project, or is your current application getting hard to evolve? Get in touch and let’s talk.


Sources