Updated
Choose a modular monolith or microservices from team ownership, transaction boundaries and operating needs, with an order-processing example.
A modular monolith is a practical starting point when one small team owns a product whose business boundaries are still changing. Microservices become useful when independently owned capabilities need independent releases, scaling or isolation, and the team can operate the resulting distributed system. User count or the word “startup” alone does not settle the choice.
The relevant question is where to place boundaries that the business and engineering team can maintain. This article explains the consequences using order processing, including how a startup can preserve an extraction path without building a service network before it needs one.
Understand what is actually being separated
A monolith deploys its application as a unit. It can still contain well-defined modules for orders, stock, customer accounts and reporting. Those modules can enforce interfaces and ownership inside one process rather than allowing every part of the code to access every table.
Microservices separate capabilities into independently deployable services. Useful independence requires more than putting existing folders into containers: shared release coordination, direct access to another service's tables, and tightly coupled changes can leave the system distributed but still interdependent.
Microsoft's microservices architecture guide describes independent services and the challenges of communication, data consistency and operational complexity. Treat those costs as design work, not as issues a platform will automatically remove.
Map an order before selecting an architecture
Consider a hypothetical startup selling configurable products. Checkout validates an order, reserves stock and records a payment attempt. The customer must not receive a confirmation for an order that the business cannot fulfill.
In a monolith, related data changes within the same database may fit in a local transaction. An external payment provider still sits outside that transaction, so retries and reconciliation remain necessary. A monolith does not make every operation atomic simply because the application runs in one process.
If order and stock ownership move to separate services, a single local transaction no longer covers both stores. The system needs explicit intermediate states, such as reservation pending, and rules for rejection, cancellation and retry. The product team must decide what customers see while those states are unresolved.
This is a business decision as well as an engineering one. If stakeholders cannot explain the compensation behavior when payment succeeds but stock reservation fails, drawing another service box will not answer it.
Compare release and team boundaries
One team making coordinated changes across the product often gains little from deploying ten services separately. It may instead inherit ten deployment configurations and more places for a partial failure to occur.
Independent services become more compelling when a capability has a stable owner and can change without requiring simultaneous changes elsewhere. For example, a document-rendering component may have a different release cadence and resource profile from checkout, with a clear request-and-result contract.
Before splitting a capability, answer:
Who owns its behavior and production incidents?
Can its interface change without synchronizing every consumer?
Which data does it own exclusively?
What happens when it responds slowly or becomes unavailable?
Can callers retry without duplicating business effects?
How will requests be traced across the boundary?
How are compatibility and rollback verified?
Which measured problem does independent deployment solve?
Unanswered questions do not prohibit a service. They describe the work that must be included in its cost and delivery plan.
Scale the measured bottleneck
A large application does not necessarily need microservices to handle more traffic. Query design, indexes, caching, background processing and application replicas may address the actual constraint. Measure where time and resources are spent before prescribing an architecture change.
Sometimes separation is justified. A CPU-intensive report generator might exhaust resources needed by interactive requests. Isolating it as a worker can help without dividing every domain into a separately owned service. An asynchronous job boundary is an option between one synchronous process and a large microservice estate.
Compare deployment options separately from domain decomposition. Our serverless versus containers guide covers runtime and operational tradeoffs; either deployment model can host different application shapes.
Keep a monolith modular in observable ways
Give modules narrow entry points and define which module owns each record. Avoid bypassing a module's rules through convenient cross-module writes. Maintain tests around business behavior so refactoring the boundary does not silently change an approval or calculation.
Record important architectural decisions while the context is available. A short explanation of why stock and order updates share a transaction can prevent a later extraction from discarding a necessary invariant.
Modularity is not established by directory names alone. Review imports, data access and changes that repeatedly touch multiple modules. When the boundary is consistently crossed, investigate whether the domain model is wrong before adding a network interface around it.
Extract one capability with a rollback plan
Choose a capability with understandable inputs, outputs and ownership. Add a stable internal interface first, prove current behavior, then route an explicitly bounded portion of work to the replacement. Decide which system is authoritative during the transition.
AWS's strangler fig pattern explains gradual replacement behind a routing layer. For a startup, the practical requirement is a reversible sequence with reconciliation and a clear retirement condition for the old path.
Avoid uncoordinated dual writes to old and new stores. If a transition requires replicated data or events, define delivery guarantees, duplicate handling, ordering assumptions and recovery from missing updates. A dashboard that looks correct immediately after migration is insufficient evidence that ongoing writes remain consistent.
Make an explicit architecture decision
Before committing to an extraction, run a bounded proof on one capability with representative data. State the hypothesis: for example, a report worker can scale independently while interactive requests remain within the team's agreed latency budget. Compare the current and proposed paths under the same workload, including a failed worker and a repeated job. Check that results reconcile, request traces identify the responsible component, and the previous path can be restored. Set the timebox and acceptance thresholds before implementation. If the proof fails, preserve the measurements and reconsider the boundary rather than turning the experiment into an unfinished production migration.
For a small product with one delivery team and uncertain requirements, document why a modular monolith meets current needs. Name the evidence that would trigger a review: an independently staffed domain, repeated release contention, a measured resource bottleneck or a concrete isolation requirement.
For a service-oriented design, include operating responsibilities in the MVP budget. Monitoring, release compatibility and recovery consume time even when the business functionality looks simple. A Pakistan-based or international team needs the same ownership clarity; geography does not determine architectural maturity.
Frequently asked questions
At how many users should a startup adopt microservices?
There is no useful universal threshold. Traffic shape, data access, reliability needs, team structure and release constraints matter more than a user count. Measure the pressure that the proposed split would relieve.
Can a monolith support external integrations?
Yes. It can expose APIs, process jobs and call third-party systems. The REST versus GraphQL guide concerns interface design, which is a separate choice from how many deployable services sit behind it.
Is starting with a monolith guaranteed to make migration easy?
No. Clear module ownership and protected behavior make future changes easier to assess, but extraction still involves data, failure handling and operational work. Preserve options without promising that a later split will be automatic.
Written by
Moueen Togarvi
Founder & CEO at Voquarn Code, focused on product engineering, search growth, and practical AI systems.
