You've seen it before. A customer places an order. Your code charges their card, reserves inventory, calls the shipping API — and the shipping API times out. The payment went through. The inventory is locked. But the order is stuck in limbo.

Now you're writing compensating transactions at 2 AM, praying your retry logic doesn't double-charge anyone.

There's a better way.

The problem: partial failure

Here's what a typical order pipeline looks like:

async function processOrder(order) {
  await validateOrder(order);
  await chargePayment(order);          // ✓ $79.99 charged
  await reserveInventory(order);       // ✓ inventory locked
  await arrangeShipping(order);        // 💥 shipping API timeout
  await sendConfirmation(order);       // never reached
}

If arrangeShipping fails, you have a real problem:

• The customer is charged

• Inventory is reserved

• But the order isn't shipped

• And if you retry from the top, you'll double-charge them

You could wrap each step in try/catch and write rollback logic. You could add idempotency keys everywhere. You could build a state machine. All of these work — and all of them are tedious, error-prone, and hard to test.

The pattern: checkpoint and resume

The idea is simple: checkpoint each step's output as it completes. When you resume after a crash, skip the steps that already succeeded and pick up where you left off.

This is essentially what saga orchestrators do, but instead of building the infrastructure yourself, you define the pipeline declaratively and let the engine handle checkpointing, retries, and resumption.

Building it with sayiir

Sayiir is a durable workflow engine with a Rust core and bindings for Node.js and Python. Let's build our order saga.

Step 1: Define the tasks

Each step in the pipeline is a task — a named, checkpointed unit of work:

import {
  task, flow, branch,
  runDurableWorkflow, resumeWorkflow, InMemoryBackend,
} from "sayiir";

const validateOrder = task("validate-order", (order) => {
  return { ...order, validated: true };
});

const chargePayment = task("charge-payment", (order) => {
  return { paymentId: `pay_${order.id}`, amount: order.amount };
}, { timeout: "30s", retry: { maxAttempts: 3, initialDelay: "1s", backoffMultiplier: 2.0 } });

const reserveInventory = task("reserve-inventory", (order) => {
  return { item: order.item, reserved: true };
});

const arrangeShipping = task("arrange-shipping", ([payment, inventory]) => {
  const trackingId = "TRACK-" + Math.random().toString(36).slice(2, 8).toUpperCase();
  return { paymentId: payment.paymentId, item: inventory.item, trackingId };
});

const sendConfirmation = task("send-confirmation", (result) => {
  return `Order complete! \({result.item} ships via \){result.trackingId}`;
});

Each task has a unique string ID ("validate-order", "charge-payment", …). That's how the engine knows which checkpoint belongs to which step. Notice chargePayment has retry and timeout config built in — no wrapper code needed.

Step 2: Compose the workflow

const workflow = flow("order-saga")
  .then(validateOrder)
  .fork([
    branch("payment", chargePayment),
    branch("inventory", reserveInventory),
  ])
  .join("merge", arrangeShipping)
  .then(sendConfirmation)
  .build();

This reads top-to-bottom: validate, then fork into parallel payment + inventory, join the results into shipping, then confirm. The fork/join runs payment and inventory concurrently — both must complete before shipping starts.

Step 3: Run it with a backend

const backend = new InMemoryBackend();
// For production: const backend = PostgresBackend.connect(process.env.DATABASE_URL);

const order = { id: "ORD-42", item: "Wireless Keyboard", amount: 79.99 };
const status = runDurableWorkflow(workflow, `saga-${order.id}`, order, backend);

Every task's output is checkpointed to the backend. If the process dies, the checkpoints survive (use PostgresBackend in production).

What happens on crash

Now let's make it interesting. What if the shipping API is down when we run?

We can simulate this with a flag that makes arrangeShipping throw:

let shippingDown = true;

const arrangeShipping = task("arrange-shipping", ([payment, inventory]) => {
  if (shippingDown) throw new Error("Shipping API is down!");
  const trackingId = "TRACK-" + Math.random().toString(36).slice(2, 8).toUpperCase();
  return { paymentId: payment.paymentId, item: inventory.item, trackingId };
});

Run 1 — shipping blows up after payment and inventory succeed:

  [validate-order]      ✓ checkpointed
  [charge-payment]      ✓ checkpointed
  [reserve-inventory]   ✓ checkpointed
  [arrange-shipping]    ✗ Error: Shipping API is down!

Status: failed

Payment went through. Inventory is reserved. The workflow is stuck at the shipping step. But here's the key — all three completed steps are checkpointed.

Now the shipping API recovers. We flip the flag and resume:

shippingDown = false;
const run2 = resumeWorkflow(workflow, "saga-ORD-42", backend);

  [validate-order]      ⟳ skipped (cached)
  [charge-payment]      ⟳ skipped (cached)
  [reserve-inventory]   ⟳ skipped (cached)
  [arrange-shipping]    ✓ checkpointed
  [send-confirmation]   ✓ checkpointed

Status: completed
Result: Order complete! Wireless Keyboard ships via TRACK-A1B2C3

Validate, charge, and inventory were skipped — their outputs were replayed from checkpoints. Only shipping and confirmation actually ran. No double-charges. No re-reservations. The workflow picked up exactly where it left off.

Why this matters

In a traditional approach, you'd need:

• Idempotency keys for every external call

• A state machine tracking which steps completed

• Compensating transactions for rollbacks

• Retry logic with exponential backoff per step

• A dead-letter queue for permanently failed orders

With durable workflows, you get all of this for free. The engine handles checkpointing, retries, and resumption. You just define the steps and their dependencies.

The full code

import {
  task, flow, branch,
  runDurableWorkflow, resumeWorkflow, InMemoryBackend,
} from "sayiir";

let shippingDown = true;

// ── Tasks ──

const validateOrder = task("validate-order", (order) => {
  console.log(`  [validate-order] Order ${order.id} is valid`);
  return { ...order, validated: true };
});

const chargePayment = task("charge-payment", (order) => {
  console.log(`  [charge-payment] Charged $${order.amount} → pay_${order.id}`);
  return { paymentId: `pay_${order.id}`, amount: order.amount };
}, { timeout: "30s", retry: { maxAttempts: 3, initialDelay: "1s", backoffMultiplier: 2.0 } });

const reserveInventory = task("reserve-inventory", (order) => {
  console.log(`  [reserve-inventory] Reserved 1× ${order.item}`);
  return { item: order.item, reserved: true };
});

const arrangeShipping = task("arrange-shipping", ([payment, inventory]) => {
  if (shippingDown) throw new Error("Shipping API is down!");
  const trackingId = "TRACK-" + Math.random().toString(36).slice(2, 8).toUpperCase();
  console.log(`  [arrange-shipping] Shipping arranged → ${trackingId}`);
  return { paymentId: payment.paymentId, item: inventory.item, trackingId };
});

const sendConfirmation = task("send-confirmation", (result) => {
  console.log(`  [send-confirmation] Email sent — tracking ${result.trackingId}`);
  return `Order complete! \({result.item} ships via \){result.trackingId}`;
});

// ── Workflow ──

const workflow = flow("order-saga")
  .then(validateOrder)
  .fork([
    branch("payment", chargePayment),
    branch("inventory", reserveInventory),
  ])
  .join("merge", arrangeShipping)
  .then(sendConfirmation)
  .build();

// ── Run ──

const backend = new InMemoryBackend();
// For production: const backend = PostgresBackend.connect(process.env.DATABASE_URL);

const order = { id: "ORD-42", item: "Wireless Keyboard", amount: 79.99 };

// Run 1 — shipping is down
console.log("=== Run 1: Shipping API is down ===\n");
const run1 = runDurableWorkflow(workflow, `saga-${order.id}`, order, backend);
console.log(`\nStatus: ${run1.status}`);
if (run1.status === "failed") console.log(`Error: ${run1.error}`);

// "Fix" the shipping service
console.log("\n--- Shipping API recovered ---\n");
shippingDown = false;

// Run 2 — resume from last checkpoint
console.log("=== Run 2: Resume from checkpoint ===\n");
const run2 = resumeWorkflow(workflow, `saga-${order.id}`, backend);
console.log(`\nStatus: ${run2.status}`);
if (run2.status === "completed") console.log(`Result: ${run2.output}`);

Try it yourself

• Playground — run the order saga in your browser: sayiir.dev/playground

• Docs — sayiir.dev

• npm — npm install sayiir

• PyPI — pip install sayiir

• crates.io — https://crates.io/crates/sayiir-runtime

Sayiir is an open-source durable workflow engine with a Rust core and bindings for Node.js and Python. Star it on GitHub if you find it useful.