Kill the worker.
Keep the workflow.

Your code is the workflow.
The history is the truth.

async function orderSaga(ctx, order) {
  const saga = ctx.saga()
  try {
    await ctx.activity('reserveInventory', order)
    saga.add('releaseInventory', order)

    await ctx.activity('chargeCard', order)
    saga.add('refundCard', order)

    await ctx.sleep(4000)            // durable
    await ctx.child('fulfillment', order)
    await ctx.activity('sendConfirmation', order)
  } catch (err) {
    await saga.compensate()          // refund, release
    throw err
  }
}

Everything a workflow needs
to outlive its process.

• replay

  Deterministic replay

  Divergence is detected and parked as a stuck workflow, never silently corrupted.

• crash

  Crash recovery

  Leases, heartbeats and epoch fencing: a dead worker's lease expires, another takes over, and the dead one's late writes are rejected. Tested by simulating a crash at the worst moment.

• time

  Durable timers

  ctx.sleep holds no worker while it waits. Any worker wakes it when it's due.

• retry

  Retries

  Attempts, backoff, jitter and non-retryable errors per activity. Every attempt is an event.

• saga

  Compensation

  Undo steps run in reverse as recorded, retried, idempotent activities.

• flow

  Signals and children

  Park on a human approval, fan out child workflows, query live state.

• ship

  Safe code changes

  ctx.patched() versions in-flight runs. A fuzzer finds hidden clock and RNG use.

• see

  Observable

  Every step is a row in Postgres you can query with plain SQL, and the playground shows the live event history. A visual timeline and inspector are in progress.

• scale

  Bounded history

  continueAsNew hands state to a fresh run so long loops never replay forever.

If it can't half-finish
or run twice, it's a workflow.

Reach for it when work takes more than a few seconds, touches more than one system, or would hurt if it stopped midway or repeated itself.

• Checkout and order fulfilment

  Reserve stock, charge the card, ship, send the receipt. If shipping fails, refund and release stock automatically, in reverse order.

  activitysagachild workflow

• Subscriptions and failed-payment recovery

  Retry a declined card on day 1, 3 and 7, then cancel. The schedule lives in the workflow, not in a cron table you have to babysit.

  sleepretries

• Onboarding with human approval

  Create the account, then wait days for a manager to approve. The workflow just sits there, costing nothing, until a signal arrives.

  signalsleep

• Reminders and trial expiry

  "Email them in 3 days unless they upgrade." One line of code, and it survives deploys and restarts.

  sleepsignal

• AI and LLM pipelines

  A multi-step agent where every model call costs money. Finished steps are replayed from history instead of being paid for again after a crash.

  activityretries

• Data pipelines and ETL

  Fetch, transform, load, with backoff on flaky sources. A job that dies at row 40,000 resumes there, and continueAsNew keeps long runs light.

  retriescontinueAsNew

• Provisioning and rollbacks

  Create a database, a bucket, a DNS record. If step four fails, tear down one to three in reverse instead of leaving orphans.

  sagaactivity

• Document and media processing

  Fan out one child workflow per file, wait for all of them, then assemble the result.

  child workflowretries

Who it's for

Run it in five minutes.
Nothing to sign up for.

1. 1

   What you need

   Node.js 20 or newer (built and tested on Node 24) and git. You do not need Docker or a Postgres install for the quickstart: it pulls a real Postgres binary through the embedded-postgres package and throws it away afterwards.

2. 2

   Get the code

   terminalCopyCopied

   $ git clone https://github.com/karmic05/durable-flow.git
   $ cd durable-flow
   $ npm install

3. 3

   Watch it survive a crash

   This starts a throwaway Postgres, runs a 3-step checkout workflow, simulates a hard crash of Worker A right after it charges the card, and lets Worker B finish the job.

   terminalCopyCopied

   $ npm run quickstart

   You'll see this (real output):

   output

   ▶ Worker A starts
      📦 reserved stock for 1001
      💳 charged $49 (key order-1001:2)
      💥 Worker A killed: the card WAS charged, but the result was never recorded
   
   ▶ Worker B starts (A is dead, its lease expires, B takes over)
      ↩︎  charge ignored, key order-1001:2 already seen
      ✉️  receipt sent for 1001
   
   ✔ completed: "order 1001 complete"
   
   Event history (what Postgres stored):
      1  WorkflowStarted
      2  ActivityScheduled  reserveStock
      3  ActivityStarted    #1
      4  ActivityCompleted  #1
      5  ActivityScheduled  chargeCard
      6  ActivityStarted    #2
      7  WorkerTakeover     A → B
      8  ActivityStarted    #2
      9  ActivityCompleted  #2
     10  TimerStarted       #3
     11  TimerFired         #3
     12  ActivityScheduled  sendReceipt
     13  ActivityStarted    #4
     14  ActivityCompleted  #4
     15  WorkflowCompleted
   
   Card charged 1× for 1 order.  No duplicate side effects.

   Read it top to bottom: the charge happened once (row 5–6), Worker A died, B took over (row 7), re-ran the step, the service recognised the idempotency key and ignored the repeat, and the workflow finished.

4. 4

   Run the test suite

   terminalCopyCopied

   $ npm test

   29 tests: replay determinism, non-determinism detection, the same crash-in-the-worst-spot scenario, a zombie worker being fenced out, retries and backoff, durable timers, sagas, signals, child workflows, continueAsNew and ctx.patched() versioning.

5. 5

   Write your own workflow

   Define workflows and activities, start one from your app, and run workers as separate processes (as many as you like).

   import { Registry, Store, Worker } from '@durable-flow/engine'
   
   const store = new Store(process.env.DATABASE_URL!)   // any Postgres
   await store.migrate()                                // creates its tables, safe to re-run
   
   const registry = new Registry()
     .workflow('welcome', async (ctx, user) => {
       await ctx.activity('createAccount', user)      // recorded; retried on failure
       await ctx.sleep(24 * 60 * 60 * 1000)           // sleeps a day, holds no worker
       await ctx.activity('sendTips', user)
       return 'done'
     })
     .activity('createAccount', async (user, ac) => {
       // call your API here. Pass ac.idempotencyKey along so a retry can't double-apply.
     })
     .activity('sendTips', async (user, ac) => { /* ... */ })
   
   // start one, e.g. from your signup handler
   await store.createWorkflow({ id: `welcome-${user.id}`, type: 'welcome', input: user })
   
   // run a worker, in its own process
   await new Worker({ id: 'worker-1', store, registry }).start()

   Honest note on packaging. It isn't on npm yet. Today, add your workflows next to examples/ in the cloned repo, or copy packages/engine/src (10 files, about 1,200 lines) into your project. An npm package is the obvious next step.
6. 6

   Use your own Postgres

   Point the store at any Postgres database (tested on 17 and 18; Neon, Supabase, RDS and local should all work). Workers can run on any machine that can reach it; the database is the only shared state.

   terminalCopyCopied

   $ export DATABASE_URL=postgres://user:pass@host:5432/dbname

The API at a glance

Not magic.
Here's what it isn't.