Two-phase commit (2PC) is not inherently bad, but it is usually a poor fit for a long-running business workflow spread across independently owned service databases. Use coordinated commit when the participants support a shared transaction-management boundary and you need atomic commit across them. For separate service databases, model the workflow as a saga; when one service must save a change and publish an event, use a transactional outbox to make that local handoff reliable.
What two-phase commit guarantees—and what it does not
2PC coordinates a commit across transactional participants through a coordinator. In the prepare phase, the coordinator asks each participant to prepare its work and be ready to commit or roll back. If all participants prepare successfully, the coordinator tells them to commit; if preparation fails, it tells them to abort.
As an Amazon Associate I earn from qualifying purchases.
This is a database-level commit protocol, not a general-purpose workflow engine. Its usefulness depends on the participants exposing compatible transactional resources and on an external transaction manager coordinating them. PostgreSQL 16 documents prepared transactions for use by external transaction-management systems. That support is evidence that 2PC is a real, supported option in the right architecture—not that every application can enlist every database and message broker in one transaction.
The phrase “2PC is not an option” needs context. AWS Prescriptive Guidance says this of systems using a database-per-service design: each service owns its store, so the architecture generally lacks one common relational coordinator across the independent databases. The statement is not a rule against 2PC in every system that stores data in more than one place.
#1 Best Overall
Why 2PC is often a poor fit for microservices
Service ownership creates a coordination boundary
In a database-per-service architecture, each service controls its data store and local transactions. Coordinating an atomic commit across those stores requires compatible participation and a shared transaction manager—capabilities that independent service boundaries may not provide. Even if they can be arranged, coupling the services to one coordinated transaction can work against their independent operation.
Business workflows have different failure semantics
A workflow such as placing an order, reserving inventory, and arranging payment may span separate systems and take longer than a short database transaction. The business may need explicit decisions about what happens after a partial success, a timeout, or a service outage. A commit protocol does not by itself define those business recovery rules.
That is the key distinction: 2PC coordinates atomic commit among participating resources; application-level workflow consistency defines how a business process progresses and recovers across service boundaries. Choosing a workflow pattern does not make every intermediate state invisible or globally atomic.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #2
How a saga handles a multi-service workflow
A saga is a sequence of local transactions. Each service commits its own step, and the workflow proceeds through further steps. When a later step fails, the design must specify whether to retry or continue forward, or to run compensating actions for earlier steps.
Compensation is not an automatic global rollback or a time machine. It is a new application action with its own business meaning and constraints; it can fail, too. For example, a system may be able to cancel an unshipped reservation but may need a separate refund process for a payment that has already settled. The exact behavior belongs to the application.
Orchestration: make the coordinator explicit
In an orchestrated saga, a workflow coordinator directs the steps and tracks progress. This makes the sequence and its state more visible in one place, which can help teams inspect and operate complex workflows. It also creates a component whose behavior and availability the system must manage.
Rank #3
Choreography: coordinate through events
In a choreographed saga, services react to events and publish events that trigger subsequent work. There is no central workflow coordinator directing every step. This can distribute responsibility, but the flow and failure paths may be harder to follow as participants and event interactions multiply.
AWS Prescriptive Guidance describes both approaches and warns that saga debugging and compensation complexity grow as the number of services and compensating actions increases. Whatever the style, retries, timeouts, idempotency, compensation, observability, and reconciliation need deliberate design.
What the transactional outbox solves
The outbox addresses a narrower problem: one service needs to update its database and notify other services. If the service commits the database change and then publishes directly to a message broker, either operation can succeed while the other fails. The database and broker can therefore disagree about whether the event exists.
Rank #4
With an outbox, the service writes both its business change and an event record to an outbox table in the same local database transaction. A separate relay later publishes the recorded event. Polling and change-data capture (CDC) are possible relay approaches where the chosen database and infrastructure support them.
This makes the local database change and the record of the event atomic with each other. It does not make publishing and consuming globally atomic, nor does it turn a multi-service workflow into one transaction. Consumers still need to handle delivery robustly, including duplicate delivery where it occurs, and the workflow still needs application-level consistency and recovery rules. The particular relay, delivery guarantees, and operational setup depend on the database, broker, and implementation.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Which pattern fits the consistency boundary?
| Situation | Pattern to consider | What it addresses | What you still need to design |
|---|---|---|---|
| One database, or compatible transactional resources coordinated by a supported transaction manager; short work requires atomic commit. | Local transaction or supported 2PC capability | Atomic commit within the participating transactional boundary. | Participant support, transaction-manager operation, and acceptable failure and operational properties. |
| A business workflow spans independently owned service databases and can tolerate explicit progress between steps. | Saga, with orchestration or choreography | Progress and recovery through a sequence of local transactions. | Retry and timeout policy, idempotency, compensation or forward recovery, visibility, and reconciliation. |
| One service changes its own database and must publish an event about that change. | Transactional outbox | Atomic persistence of the local business change and the event record. | Relay operation, consumer delivery handling, and any broader workflow consistency rules. |
The right choice depends on the required atomicity boundary, participant support, workflow duration, tolerance for intermediate states, recovery semantics, observability, and operator burden. There is no workload-independent basis here for claiming that one pattern is universally faster or more available.
A practical design sequence
- Identify the invariant. State which data must change together and whether that invariant belongs inside one database or crosses service ownership boundaries.
- Check the transaction boundary. Confirm that every participant supports the required transactional protocol and that a transaction manager can coordinate it. If not, do not assume 2PC can enlist those resources.
- Choose what partial progress means. For a multi-service workflow, decide whether a failed step should be retried, followed by forward recovery, or handled with a compensating action. Define the business result if compensation is impossible or fails.
- Close the local dual-write gap. If one service must save a change and announce it, persist an outbox event in the same local transaction, then operate a relay and design consumers to handle delivery safely.
- Plan operations before rollout. Specify how the system exposes workflow state, detects stalled work, applies timeouts and retries, and reconciles cases that automated recovery cannot settle.
When keeping data together is simpler
If a business invariant truly requires atomicity and dividing its data across services would force a complicated distributed workflow, keeping that data within one transactional boundary may be the simpler design. That is an architectural tradeoff, not a universal case for centralizing every service or avoiding distributed systems.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
