Moving from a monolith to microservices works when you do it one capability at a time, behind the running system, with each split tied to a problem you can name. It fails when it becomes a rewrite that freezes your roadmap for a year. We build platforms, migrations and integrations for brands with real volume, and the pattern is the same each time: keep the current system live, carve off the piece that hurts most, move traffic gradually, and stay on after launch so the new service is run, not just delivered.
This guide is for business and technical leaders who own a system that has grown heavy. It covers when to split, how to find the seams, how to handle data, what you need to run services safely, and where migrations go wrong.
TL;DR
- Split a monolith when you can name the pain: a component that scales differently, teams blocking each other’s releases, or build and test times that keep growing.
- Migrate incrementally with the strangler fig pattern: new services grow beside the old system while traffic moves over, and the monolith stays as a rollback path.
- Data is the hard part. Services that share a database are a distributed monolith with extra network calls.
- Budget for operations: CI/CD, logging, monitoring, tracing and a named owner for every service.
- Start with one or two edge services, not the core, and treat the work as continuous rather than a project with a finish line.
Table of Contents
- What actually changes when you leave a monolith
- Signs a capability has earned its own service
- Find the boundaries before you cut
- Migrate without a rewrite: three patterns that work
- Data is the hard part
- What you need in place to run services safely
- Where migrations go wrong
- A practical sequence
- How Dogtooth fits
- Our perspective
- FAQ
- Sources
What actually changes when you leave a monolith
A monolith is one deployable unit: your storefront, billing, reporting and user accounts ship together, share one codebase and usually share one database. Microservices split that into small services, each owning a business capability and its own data, talking to the others through APIs or events.
The case for splitting is mostly about independence. AWS’s decomposition guidance lists what microservices can fix: high support and learning costs from a poorly defined internal structure, slow feature delivery caused by tight coupling, the inability to scale one component on its own, and the coordination overhead of many teams shipping one large release.
The microservices.io write-up on monolith limits adds two symptoms most growing companies recognize. You cannot upgrade the technology stack piece by piece, because there is one runtime and one deployment unit. And as the codebase grows, build and test times stretch until the pipeline becomes the bottleneck and release frequency flattens out.
The cost side is real, and Martin Fowler’s microservices guide names it plainly: remote calls are slower and fail more often than in-process calls, strong consistency across services is very hard, and you need a mature operations function to manage many services that are redeployed often. Those costs are the price of independence, and the rest of this article is about paying them deliberately.
Signs a capability has earned its own service
Do not start from the architecture diagram. Start from the symptom. These are the signals that justify a split:
- Different scaling curve. One component takes ten times the traffic or compute of the rest, such as search, media processing, or a checkout flow during a promotion. Scaling the whole application for one hot path wastes money.
- Release contention. Teams wait on each other, merge into one pipeline, and coordinate every deploy. AWS calls out multi-team coordination for a single large release as a core driver.
- Isolation needs. Payment data, regulated records or anything with its own compliance scope is easier to defend when it lives in a smaller, separately controlled surface.
- Different runtime needs. A component that wants another language, a different data store or specialized hardware cannot get it inside one shared stack.
If you cannot connect your pain to one of these, the better first move is usually to tighten module boundaries inside the existing application. That gets you most of the clarity at a fraction of the operating cost, and it makes a later split far cheaper. Either way, you end with a cleaner system and a clear reason for each service you do extract.
A short worked example: an online retailer’s monolith handles catalog, cart, checkout, order history and email. Checkout spikes on sale days and carries payment scope, while the catalog changes weekly and order history barely moves. Checkout is the candidate: it scales differently and needs isolation. The other modules stay put until they show a symptom of their own.
Find the boundaries before you cut
The most common mistake is slicing by technical layer (a database service, a UI service) instead of by business capability. Microsoft’s guidance on identifying microservice boundaries starts from a bounded context, a part of the business with its own vocabulary and rules, and then examines the entities and domain services inside it. It also asks you to weigh team size, data types, scalability, availability and security.
A good candidate passes these checks:
- It has a single responsibility you can describe in one sentence.
- It does not need chatty back-and-forth calls with its neighbors.
- It can be deployed without deploying anything else.
- Its data boundary does not create consistency problems you cannot solve.
Microsoft also recommends starting with coarser-grained services, because splitting one service into two later is easier than untangling logic scattered across several tiny ones. Its assessment guidance suggests beginning with edge services that have few dependencies, which lets your team learn deployment, monitoring and rollback on something low-risk.
Research published in Communications of the ACM goes further. In their study of incremental transitions to microservices, the authors note that most organizations lack the resources of born-digital giants and recommend splitting off only two or three services per development effort, leaving the rest in the monolith core.
A useful artifact at this stage is a dependency map: which modules call which, which tables each module reads and writes, and which jobs touch several areas at once. The tables matter most, because that is where the real coupling hides. If you are also reworking the interfaces between systems, our piece on API-first architecture explains how to design the contract before the code.
Migrate without a rewrite: three patterns that work
A big-bang rewrite stops feature work, forces you to reproduce years of behavior from memory, and delivers all its risk on one date. Incremental patterns avoid that. Our guide to legacy system migration in five phases covers the same principle for any aging platform; for microservices specifically, three patterns do most of the work.
Strangler fig
AWS describes this as three steps. Transform: build or port a component alongside the legacy application. Coexist: keep the monolith running for rollback, put an HTTP proxy or API gateway in front, and redirect traffic to the new service as it proves itself. Eliminate: retire the old functionality once traffic has moved. The monolith shrinks until nothing is left that needs to be there, or until what remains is small and stable enough to keep. We go deeper on this approach in API modernization without a big bang.

Branch by abstraction
When the capability sits deep inside the monolith and has no clean network seam, you create an abstraction layer over it, switch callers to the abstraction, build the new implementation outside the monolith, then switch the abstraction to point at it. The old implementation is deleted when nothing uses it. This is slower to set up than a proxy, but it works for internal code paths no outside request ever touches.
Extract inside the repository first
Engineers at Glovo described extracting a subscriptions domain into a separate module inside the monolith repository, shared by the monolith and the new service, with database access encapsulated in that module. They moved business logic first and migrated the data only after cutting cross-domain constraints and transactions. The lesson is sequencing: separate the code, then the transactions, then the data.
Phasing like this is not unique to software. Even a six-phase CMS migration for operators is built around moving in stages so that live operations never stop, and the same logic applies to your application.
Data is the hard part
Code moves easily. Data does not. Zhamak Dehghani, in a piece hosted on Martin Fowler’s site, identifies multiple applications reading and writing a single shared data store as the main blocker to decoupling. If two services can read each other’s tables, you have a distributed monolith: all the network failure modes of microservices with all the coupling of the original.
Plan for these realities:
- Joins move into the application. Sam Newman and Leandro Guimarães explain in an InfoQ discussion that a join once done in the database becomes a sequence of service calls, such as fetching top item IDs from one service and then details from another. That can add latency compared with a single database round trip.
- Writes must be synchronized during the transition. Microsoft’s assessment guidance lists data synchronization, multiple writes to both monolith and service, schema decomposition, data volume and integrity as the reasons data is hard to break up.
- There is a spectrum of options. From a temporary shared database, through views and API wrappers where full separation is impractical, to a database per service as the end state.
- Consistency changes. Once data is service-owned, you cannot rely on one transaction spanning boundaries. Workflows that cross services need patterns such as sagas, and reads across boundaries go through APIs or event-driven projections.
The CACM authors say data ownership, not code, is usually the hardest part to split, and they warn that poorly defined cross-boundary services produce mini-monoliths. Decide who owns each piece of data before you write the service, and write that decision down. For the mechanics of moving the data itself, including cutover, see our database migration strategy guide, and for systems that cannot go offline, zero downtime migration. If one platform serves many customers, the multi-tenant architecture guide covers how tenant data should be separated.
What you need in place to run services safely
Microservices trade code complexity for operational complexity. The teams that succeed treat the following as part of the migration, not as an afterthought.
Ownership. An O’Reilly survey of 1,502 respondents found that teams owning the full build, test, deploy and maintain lifecycle succeeded at a rate 18% higher than those that did not. An academic study of 21 practitioners and 37 companies, Promises and Challenges of Microservices, found that assigning an explicit owner to each service improves quality, and that over 90% of survey participants believed logging and monitoring should be set up from the start of the project.
Independent pipelines. Microsoft’s CI/CD guidance for microservices says each team must be able to build and deploy its services independently, with quality gates before production, side-by-side deployment of new and previous versions, vulnerability scanning of container images and contract tests that surface integration problems early.
Observability. Centralized logs, metrics and distributed tracing, so a slow checkout can be traced across five services instead of guessed at.
Testing at several levels. Unit and integration tests per service, plus end-to-end tests for the critical journeys. Contract tests, where a consumer’s expectations of an API are checked in the provider’s pipeline, are the piece teams skip most often. In a survey-and-interview study of industry practice, only 13 of 51 systems used consumer-driven contract tests, compared with 47 of 51 using unit tests.
Security as a team capability. NIST’s DevSecOps guidance for microservices describes organizing a group of developers, security specialists and IT operations, with test coverage that includes system-level tests as well as low-level ones.

Where migrations go wrong
The failure modes repeat:
- Splitting without a named reason. You pay the operational bill and get nothing back.
- Shared databases. Services that read each other’s tables cannot deploy independently.
- Extracting too much too fast. The CACM recommendation of two or three services per effort exists for a reason: every new service multiplies the monitoring, ownership and testing you must support.
- No platform foundation. Without templates, automated builds and deployment, each new service becomes a mini-project. CarGurus reported cutting production onboarding to seven days by eliminating manual ticketing and bootstrapping a service template.
- Treating it as a project with an end date. Large migrations are continuous. The monolith shrinks, the platform matures, and the boundaries get revisited as the business changes.
The same discipline applies at larger scale. Truist Bank’s Digital Straddle program bridged several core platforms after a merger with an identity layer and an experience API over microservices middleware that abstracts the back-end systems of record. All 9 million clients were migrated by October 2021. The takeaway for a smaller company is the structure: put a stable interface in front of the old systems, then change what is behind it.
A practical sequence
- Name the pain and a measurable target. Deploy frequency, build time, infrastructure cost for the hot path, or incident count.
- Map dependencies and data. Modules, tables, scheduled jobs and third-party integrations.
- Tighten the monolith’s internal boundaries. Modules with clear interfaces make every later step cheaper.
- Stand up the platform basics. Pipeline, logging, monitoring, tracing, a service template.
- Extract one edge service. Route a slice of traffic through a gateway, compare behavior, and keep the monolith path for rollback.
- Move the data deliberately. Separate transactions first, then ownership, with synchronization during the overlap.
- Retire the old code. Delete it. Dead code left in the monolith keeps its maintenance cost.
- Repeat for the next capability, using what the last one taught you.
How Dogtooth fits
A migration like this touches code, data, integrations and operations at once, and it runs for months after the first service ships. Dogtooth’s Platform Builds & Migrations and Integrations & APIs services are built for that situation: a senior-led team that ships weekly, builds custom platforms and migrations for brands doing real volume, and stays on after launch. We run our own operation on the same AI-in-the-workflow approach we build for clients, so what we recommend is what we use.
If you want to see a migration in practice, our Drupal 6 research platform migration case study shows how an aging system moves to a modern stack. When you are ready to scope your own, start at Dogtooth’s services overview.

Our perspective
Most of the teams that come to us are not asking for microservices. They are asking why releases take so long, why one slow feature drags everything down, or why nobody wants to touch the old code. Microservices are one answer to those questions, and the right answer when the pain is specific.
Our approach is the one in this article: keep the current system live, pick the capability that hurts most, put a clean interface in front of it, and move traffic gradually. We favor this because a senior team can deliver something every week that the business can see, instead of a rewrite that shows nothing until a cutover date.
We also think the work is not finished at launch. Services need owners, monitoring and a team that understands how they fit together. That is why we stay on after a project ships, and why we build platforms that scale with the operation rather than around it.
Chase Weir
FAQ
How long does a monolith to microservices migration take?
It depends on the size of the system and how many capabilities you extract, so there is no honest single number. Plan in increments of one or two services, each delivered and running in production before the next begins. Large migrations are continuous efforts that run alongside normal feature work rather than a project with a fixed end.
Do I have to rewrite my application?
No. The strangler fig and branch by abstraction patterns let you build new services beside the existing application and move traffic across gradually. The monolith stays available as a rollback path until the new service has proven itself, so the product keeps shipping throughout.
What is a distributed monolith, and how do I avoid one?
It is a set of services that deploy separately but remain tightly coupled, usually through a shared database, long chains of synchronous calls or shared libraries. Avoid it by giving each service ownership of its own data, defining narrow APIs between services, and testing the contracts between them in your pipeline.
Which part of the monolith should I move first?
Choose a capability with few dependencies and a clear reason to be separate, such as a component that scales on its own curve or carries its own compliance scope. Edge services let your team learn deployment, monitoring and rollback before you touch the core.
Sources
- AWS Prescriptive Guidance: Decomposing monoliths into microservices
- microservices.io: When to use the microservice architecture, part 5
- Martin Fowler: Microservices Guide
- Microsoft Azure Architecture Center: Identify microservice boundaries
- Microsoft Azure Architecture Center: Microservices assessment and readiness
- Communications of the ACM: How to transition incrementally to microservice architecture
- Glovo Engineering: A tale of microservice extraction, part 2
- Martin Fowler: How to break a monolith into microservices
- InfoQ: Migrating monoliths to microservices with decomposition
- O’Reilly: Microservices adoption in 2020
- Promises and Challenges of Microservices (EMSE 2021)
- Microsoft Azure Architecture Center: CI/CD for microservices
- No Free Lunch: Microservice Practices Reconsidered in Industry
- NIST SP 800-204C: DevSecOps for microservices
- CarGurus: Decomposition journey from monolith to microservices
- Truist: Digital Straddle case study
- Six-phase CMS migration for operators



