Saga Architecture in Scala

Distributed systems rarely give you one big ACID transaction across services. When a workflow spans inventory, payments, shipping, and notifications, partial failure is normal—and you need a clear way to move forward or undo work with compensating actions. This book teaches saga patterns by building a single, coherent example in Scala 3 and ZIO: an order-placement flow with reserves, charges, shipments, and customer notifications.

You work through complete source files as they appear in the project (the book presents 100% of the code across the chapters), so you always see real traits, types, layers, and tests—not fragments disconnected from a runnable design. Early chapters establish the Scala 3 choices that matter for sagas (opaque types, enums, immutability, service traits) and ZIO as the effect model: typed errors, sequential composition, and how that maps to “run steps, then compensate in reverse order.” ZLayer and ZIO.service show dependencies as values and keep orchestration testable.

The narrative moves from why global transactions and two-phase commit are a poor fit to saga concepts: steps and compensations, orchestration vs choreography, ordering, recovery, and consistency at boundaries. You implement orchestration with an explicit saga step type and runner, then choreography with domain events and reactions—so you can compare the same domain under two coordination styles. Testing is first-class: in-memory interpreters, test doubles, and strategies to assert that compensations run when you expect.

Later chapters bridge simulation to production: swapping interpreters (e.g. HTTP), reliability concerns, outbox/inbox, idempotency, retries, saga state persistence, and operational topics like observability and runbooks. An appendix sketches the same ideas in Cats Effect for readers who prefer that stack; others provide a code index and an ADR template for documenting saga policies.

Audience: Scala developers who already know the basics (e.g. Option, Either, some familiarity with effects) and want a rigorous, code-complete path from saga theory to implementation and operations—not a framework tutorial alone, but architecture with executable Scala.