Four teams, one release
A company that sells practice-management software to veterinary clinics runs it as one application. Appointments, medical records, the pharmacy's stock and the reminder texts sent to pet owners live in one codebase, are built and deployed together, and share one PostgreSQL database. That is a monolith: one deployable, the simplest shape to build, test and reason about.
The product has grown to four teams, one per area, and they all ship through one weekly release. The records team is halfway through a schema change, so the appointments team's bug fix waits for the release with everything else. Someone proposes microservices: split the system into independently deployable services that each ship and scale on their own. The autonomy is real; the cost hides inside calls that are nearly free today.
What a function call turns into
Booking a vaccination checks the pet's record and reserves a dose from the pharmacy's stock. Inside the monolith those are two function calls and one database transaction: records.vaccinationStatus(petId) costs little beyond the work it does, and if the reservation fails, the whole booking rolls back. Make Records and Pharmacy services of their own and each call crosses the network, which changes four things at once:
- Latency. Each call adds a network round trip and the work of encoding and decoding the request, usually from a fraction of a millisecond to a few milliseconds inside one data centre, and more on the slowest requests. A booking that makes three calls one after another pays it three times.
- Partial failure. Records can be down while Appointments is up, which one process mostly does not face, since its parts run and fail together. A call can also time out after Pharmacy did reserve the dose, so Appointments cannot tell whether it happened, and its code has to handle that answer.
- Split data. Each service should own its data, and no other service reads or writes it directly. Then the dose and the booking are committed by two services and no local transaction covers both, so the booking usually becomes a chain of local steps with a compensation when one fails, and Saga deals with their ordering and with the halfway states other requests can see. Tomorrow's appointment list, which shows each pet's last vaccination, is no longer one SQL join either; Database per Service works through what replaces it.
- More to run. Four services are four things to deploy, watch and recover, even when they share tooling and an on-call rotation. Clients usually get one entry point (API gateway & the edge), services need to find each other's instances (Service discovery & the mesh), and a slow booking has to be followed across every hop (Distributed tracing). Without that supporting cast, and the CI/CD to ship each service alone, the services exist but are harder to run than the monolith was.
Boundaries before the network
Look closely, though, and part of the complaint is usually coupling inside the code: when any change can break any area, everything ships together, carefully. Much of that can be fixed with no network. A modular monolith keeps one deployable but divides it into modules, each owning its own tables and reachable only through the interface it publishes, often with a build check that fails when one module imports another's internals or queries its tables. Booking still calls Records in-process and commits in one transaction; what it does not give is a separate release. Most products don't need microservices on day one, so this well-structured monolith is the usual start, and a service is extracted when team ownership or scaling pressure demands it, along a module boundary that has already held up in code.
A seam worth cutting
Reminders is the clinic's first candidate. It sends tens of thousands of texts in a burst every evening, a load shape nothing else in the system has, and it only needs to hear that an appointment was booked, moved or cancelled; no booking waits for its answer. Extracted, it gets its own store and subscribes to AppointmentBooked and its siblings. When it is slow or down, bookings carry on; once it catches up on the events, as long as the event bus still holds them, it sends the reminders that are still valid, late.
Records is the opposite. Nearly every booking, prescription and invoice reads it, often more than once per request. Cutting there turns the busiest in-process call into a network call, for a part with no different load, where a separate release for the records team would not pay for that. A seam is worth cutting when few calls cross it, few of those need an answer within the user's request, its data clearly belongs on one side, and the team or the load on that side differs from the rest. Where those lines fall in the domain, before any code moves, is the question Bounded Context answers.
The clinic app publishes booking events and never waits for Reminders. Records stays inside, where its calls are still function calls.
Services that still ship together
Cut in the wrong places and the result is a distributed monolith: services that must change and deploy together, with network calls between them that let a failure in one spread to the others. It pays the costs of both shapes and keeps few of the benefits of either, and it shows in three symptoms:
- Lockstep deploys. Appointments cannot ship until Records ships the same change, because each depends on the other's request and response shapes changing at once. Two services that always deploy together are one deployable in two pieces.
- One shared schema. The services still read and write the clinic's single database, so the records team's migration still blocks everyone, now with extra latency on every call. Shared Database follows where that leads.
- Chatty synchronous chains. A booking calls Records, which calls Pharmacy, which calls Owners for contact details, each waiting on the next. One request now depends on every service in the chain being up and fast, and a slow one, without timeouts, can stall all its callers; Cascading failures: how one dependency takes down its callers shows how that spreads.
The quickest check is whether a team can deploy its service on its own, with no change or coordinated release in another service. If it cannot, the split is not yet buying the independence it was made for, and without another concrete reason, such as team ownership, scale or isolating a failure, its network and operations cost is hard to justify.
The cut you have to defend
The Monolith to Microservices Challenge puts you where the clinic stood: one capability leaves a legacy monolith, without a big-bang rewrite, in at most 16 nodes. The facade and traffic shift in its brief belong to Strangler Fig; the decision this article is about is which capability goes first, and that is the choice to defend. Argue it with the seam test: how many calls cross the new boundary, how many a user's request waits on, and whose data moves. Then name the bill you accept: a datastore of the new service's own, kept in sync with the monolith while both run, as the brief asks, and each synchronous call still crossing the boundary, a round trip and one more way for a request to fail.
What a split does not buy, by itself, is better structure. Split a tangle as it stands and modules that reached into each other's internals become services that reach into each other's APIs, slower and harder to change together. The independence comes from the boundary; the network only makes a bad boundary more expensive.