"Should we build microservices?" is one of the most common architecture questions we hear from product teams, and the honest answer is: probably not yet. Microservices solve real problems, but they also introduce real complexity. Choosing well means understanding both sides.
What is a monolith?
A monolith is a single deployable application containing all of your features: authentication, billing, orders, notifications and so on. Modules share one codebase, one database and one release process.
Advantages
- Simple to develop, test, debug and deploy, especially for small teams.
- In-process function calls are fast and transactions are straightforward.
- Lower infrastructure and operational cost.
Drawbacks
- A large, tangled codebase becomes hard to change safely.
- The whole application must be redeployed for any change.
- You cannot scale one hot feature independently of the rest.
What are microservices?
Microservices split the system into small, independently deployable services, each owning a specific business capability and its own data. Services communicate over APIs or messaging such as REST, gRPC or event streams.
Advantages
- Teams can build, deploy and scale services independently.
- Failures can be isolated, and each service can use the best-suited technology.
- Clear ownership boundaries help large organisations move in parallel.
Drawbacks
- Distributed-system complexity: network latency, partial failures and eventual consistency.
- Much heavier operations: service discovery, tracing, centralised logging, CI/CD per service.
- Data consistency across services needs patterns such as sagas and the outbox pattern.
How to decide
- Team size: fewer than about 15 engineers rarely benefit from microservices.
- Domain clarity: if your product boundaries are still changing weekly, keep them in one codebase.
- Scaling needs: split out a component only when it has genuinely different scaling or reliability requirements.
- Operational maturity: make sure you have CI/CD, monitoring and on-call practices before adding services.
The middle path: the modular monolith
For most SaaS products we recommend starting with a modular monolith: one deployable application with strictly separated modules, clear internal APIs and no cross-module database access. It delivers most of the maintainability benefits of microservices without the operational overhead, and it makes later extraction of a service far easier.
Migrating safely
- Use the strangler pattern: route one capability at a time to a new service while the monolith keeps running.
- Extract the components with the clearest boundaries first, such as notifications or file processing.
- Give every new service its own data store and a versioned API contract.
- Invest in observability (structured logs, metrics and distributed tracing) before splitting.
Conclusion
Architecture should follow your team and your product, not trends. Start with a well-structured, modular monolith, measure real bottlenecks, and extract services only when the benefit clearly outweighs the operational cost.
