The saga pattern

// One step of the state machine (Amazon States Language)
"ReserveStock": {
  "Type": "Task",
  "Resource": "arn:aws:states:::lambda:invoke",
  "Parameters": { "FunctionName": "reserve-stock", "Payload.$": "$" },
  "Retry": [{
    "ErrorEquals": ["Lambda.ServiceException"],
    "MaxAttempts": 3, "BackoffRate": 2
  }],
  "Catch": [{
    "ErrorEquals": ["States.ALL"],
    "Next": "RefundPayment"   // start compensating
  }],
  "Next": "ShipOrder"
},
"RefundPayment": { "Type": "Task", ..., "Next": "CancelOrder" }

1. Retry handles blips: a timeout isn't a business failure.
2. Catch is where real failures turn into compensation.
3. Compensations are just more states, chained in reverse order.
4. Steps after the pivot get Retry only, no Catch to compensation.

// The workflow is the expediter, written as plain Java
public void placeOrder(Order order) {
  Saga saga = new Saga(new Saga.Options.Builder().build());
  try {
    payments.charge(order);
    saga.addCompensation(payments::refund, order);

    inventory.reserve(order);
    saga.addCompensation(inventory::release, order);

    shipping.ship(order);  // pivot: retried, never undone
  } catch (ActivityFailure e) {
    saga.compensate();     // runs the undos, newest first
    throw e;
  }
}

1. Each call is an activity, often a call to another Spring Boot service.
2. Register an undo only after its step succeeds.
3. Temporal saves progress after every step, so a crash resumes instead of restarting.
4. Same idea: Camunda, Axon, Eventuate Tram.

// Payment service: hear OrderPlaced, react, announce
@KafkaListener(topics = "order-events")
@Transactional
public void on(OrderPlaced event) {
  if (processed.existsById(event.eventId())) {
    return;                 // bell rang twice: ignore
  }
  payments.save(Payment.forOrder(event));
  outbox.save(OutboxEvent.of("DepositPaid", event.orderId()));
  processed.save(new ProcessedEvent(event.eventId()));
}  // all three rows commit together, or none do

// A relay (Debezium, or Spring Modulith's event
// externalization) moves outbox rows to Kafka.

1. Idempotency: the processed-events table is the ticket-number check.
2. Outbox: the event is a row in the same transaction, never a separate send.
3. Compensation is just another listener, e.g. on StockUnavailable.