Implementing Saga Pattern for Distributed Transactions

Imagine an e-commerce site with hundreds of thousands of orders per day. After a successful payment, the delivery service goes down, and data gets out of sync: money deducted but order not shipped. Without proper management of distributed transactions, such scenarios lead to financial losses and customer churn. The Saga Pattern solves this by breaking a business transaction into local steps with compensations on failure. We have been implementing sagas in microservice systems for over 5 years — contact us for a turnkey solution with data integrity guarantee.

Two Types of Saga

Choreography — services react to each other's events without a central coordinator. Each service publishes events to a broker (e.g., Kafka) and subscribes to relevant ones. If payment fails, the Inventory Service rolls back the reservation via an inverse event.

Orchestration — a central Saga Orchestrator (e.g., Temporal) explicitly manages steps and compensations. Code is clearer, easier to debug, but requires a separate service.

How to Choose Between Orchestration and Choreography?

If you have up to 5 services and simplicity of debugging is crucial — choose orchestration. For large systems with 10+ services and high load, choreography via Kafka provides better scalability. We often combine both: orchestration for critical chains, choreography for background processes. Our engineers will select the right approach for your project — get in touch for a consultation.

What Is Temporal and Why Do You Need It?

Temporal is a production-ready engine for long-running workflows. It automatically retries activities, stores execution history, and lets you inspect sagas via UI. It guarantees compensation execution even if a service crashes. Over 95% of sagas with Temporal complete without manual intervention. According to our data, orchestration via Temporal is 2-3 times more reliable than choreography without a coordinator. Example orchestration with Temporal:

import { proxyActivities, sleep } from '@temporalio/workflow'; const { reserveStock, chargePayment, createShipment, releaseStock, refund } = proxyActivities({ startToCloseTimeout: '10 seconds' }); export async function createOrderWorkflow(input: CreateOrderInput): Promise<void> { let stockReserved = false; let paymentCharged = false; try { await reserveStock({ orderId: input.orderId, items: input.items }); stockReserved = true; await chargePayment({ orderId: input.orderId, amount: input.amount }); paymentCharged = true; await createShipment({ orderId: input.orderId, address: input.address }); } catch (error) { // Temporal ensures compensations execute if (paymentCharged) { await refund({ orderId: input.orderId }); } if (stockReserved) { await releaseStock({ orderId: input.orderId }); } throw error; } } 

Persistent Saga with State

A saga must survive service restarts. State is stored in a database (PostgreSQL, MySQL). We use a table with statuses (running, completed, failed, compensating) and context. When a service crashes, it re-reads incomplete sagas and continues from the last step.

interface SagaState { sagaId: string; sagaType: string; status: 'running' | 'completed' | 'failed' | 'compensating'; currentStep: number; context: Record<string, unknown>; completedSteps: string[]; failedStep?: string; createdAt: Date; updatedAt: Date; } class PersistentSagaOrchestrator { async startSaga(sagaType: string, context: unknown): Promise<string> { const sagaId = uuidv4(); await this.sagaRepo.save({ sagaId, sagaType, status: 'running', currentStep: 0, context, completedSteps: [] }); await this.executeSaga(sagaId); return sagaId; } } 

Choreography via Kafka

Example event handling in the Inventory service:

// Order Service publishes an event await kafka.producer.send({ topic: 'order.events', messages: [{ key: orderId, value: JSON.stringify({ type: 'OrderCreated', orderId, items, customerId })}] }); // Inventory Service listens and reserves kafka.consumer.subscribe({ topic: 'order.events' }); kafka.consumer.run({ eachMessage: async ({ message }) => { const event = JSON.parse(message.value.toString()); if (event.type !== 'OrderCreated') return; try { await inventoryService.reserveStock(event.orderId, event.items); await kafka.producer.send({ topic: 'inventory.events', messages: [{ key: event.orderId, value: JSON.stringify({ type: 'StockReserved', orderId: event.orderId })}] }); } catch { await kafka.producer.send({ topic: 'inventory.events', messages: [{ key: event.orderId, value: JSON.stringify({ type: 'StockReservationFailed', orderId: event.orderId })}] }); } } }); 

Common Problems and Solutions

What’s Included in the Work

The implementation process covers:

• Analysis: define business transactions, service boundaries, failure points.
• Design: choose between orchestration and choreography, prepare compensation plan.
• Implementation: write saga code, integrate with Temporal or Kafka, ensure idempotency.
• Testing: unit tests, integration tests, failure scenario tests (chaos engineering).
• Deployment: deploy in Docker/Kubernetes, set up monitoring (Jaeger, Grafana).

Deliverables: saga documentation, repository access, team training, and 2 weeks of post-launch support.

Timelines and Guarantees

• Simple orchestration (2-3 services, without Temporal) — 1 to 2 weeks.
• Orchestration with Temporal + monitoring — 2 to 3 weeks.
• Choreography via Kafka with idempotent handlers — 2 to 4 weeks.

Cost is determined individually after analysis. We offer a 6-month code guarantee. Over 100 delivered projects in microservices (5+ years in the market). Contact us for a free project assessment and an optimal solution.

Further reading: Saga pattern (Wikipedia).