Manage a multi-service “transaction” as a sequence of local transactions + compensating actions.

Data Flow (choreography)

OrderService -> emits OrderCreated
  PaymentService  -- listens -> charges card -- emits PaymentCompleted
  InventoryService -- listens -> reserves SKU -- emits InventoryReserved

if any step fails:
PaymentService    -> emits PaymentRefundNeeded
InventoryService  -> emits InventoryRelease
OrderService      -> marks order FAILED

Two styles

• Orchestration: a central orchestrator (e.g. Temporal, AWS Step Functions) commands each step.
• Choreography: services listen to events and react — no central controller.

Pitfalls

• Compensating logic bugs: a refund fails after inventory was released. You need idempotent, retryable compensations.
• No idempotency makes retries unsafe.
• Observability gaps: 8 services, 5 steps, all async — hard to trace.

When to use

• Booking a flight + hotel + rental car across three providers.
• Any cross-database “all-or-nothing” operation that cannot use 2PC.

Analogy

A road trip with many stops: each stop is one local task; if the last stop is closed, you reverse course to undo priors.

Interview tip: Always mention compensations are not free — design idempotency from day one.