workflowd — durable workflows, woven to last

The problem

Every team rebuilds this badly

Payment flows, onboarding sequences, billing cycles, approval chains. They all need to survive crashes — and they're all usually built from Redis queues, cron jobs and a status column.

The DIY version breaks

Queues plus status flags lose state on crashes, can't replay, and breed idempotency bugs. "Did the charge go through before the pod died?" has no answer in your data.

The robust version is enormous

Temporal and Cadence solve it properly — and ask for Cassandra or MySQL, several services, Kubernetes, and someone to run it. Most teams cannot justify that.

The gap this fills: durable execution you can run in under five minutes. One binary, one data directory, a Go SDK. Your workflow crashes, restarts, and picks up exactly where it left off.

The pattern book

Proven weaves, ready to run

Four workflows almost every team needs, written against the real SDKs. Each one leans on a different guarantee — pick the thread that matches your problem.

The saga — charge, ship, never half-do it

Reserve stock, charge the card, ship. If the process dies between "charged" and "shipped", a queue-plus-flags build has no answer — the money moved and nothing else did.

On the loom: every step lands on the card chain before it runs. A crash mid-saga replays to the exact pick; exhausted retries hand you an ordinary error, so compensation is just an if-statement.

Saga compensationRetries with backoffDurable history

Goorder_workflow.go

func OrderWorkflow(ctx sdk.Context, input []byte) ([]byte, error) {
	reserved, err := ctx.ExecuteActivity("reserve", input)
	if err != nil {
		return nil, err // failed before any money moved
	}

	// Retries are engine policy (SetRetryPolicy); this error only
	// surfaces once every attempt is exhausted.
	if _, err := ctx.ExecuteActivity("charge", reserved); err != nil {
		ctx.ExecuteActivity("release", reserved) // compensate
		return nil, fmt.Errorf("charge failed, released: %w", err)
	}

	ctx.Sleep("settle", 2*time.Second) // durable across restarts

	return ctx.ExecuteActivity("ship", reserved)
}

The drip — onboarding that remembers where it was

Welcome email today, nudge on day 3, last call on day 7, close the account if they never activated. Cron jobs plus a stage column forget which user was where the first time you deploy.

On the loom: the waits are durable timers with deadlines on disk. Redeploy, restart, upgrade the engine — each user's sequence resumes exactly where it stood, days or weeks later.

Durable timersWeeks-scale waitsTypeScript SDK

TypeScriptonboarding.mjs

const DAY = 24 * 60 * 60 * 1000;

worker.workflow('Onboarding', async (ctx) => {
  await ctx.activity('send-welcome', ctx.input);

  await ctx.sleep('day-3', 3 * DAY);            // deadline is on disk
  if (await ctx.activity('is-active', ctx.input)) return 'active';

  await ctx.activity('send-nudge', ctx.input);

  await ctx.sleep('day-7', 4 * DAY);
  if (await ctx.activity('is-active', ctx.input)) return 'active';

  await ctx.activity('close-account', ctx.input);
  return 'dormant';
});

worker.activity('send-nudge', async (email) => {
  await postmark.send({ to: email, template: 'nudge' });
});

The relay — park until the outside world answers

Authorize now; the processor's webhook decides what happens next. It might arrive in 200ms or after a bank-holiday weekend. Holding a process open for that shouldn't require holding anything in memory.

On the loom: the workflow parks on a signal at zero cost. A webhook that arrives before the wait is buffered on the card chain, never lost — delivery becomes at-least-once instead of "hopefully".

SignalsBuffered early eventsPython SDK

Pythoncapture.py

@worker.workflow("Capture")
def capture(ctx):
    auth = ctx.activity("authorize", ctx.input)      # hold the funds

    # Park until the PSP calls back. Costs nothing while parked;
    # signals sent before this line are buffered, not dropped.
    event = ctx.wait_for_signal("psp", "webhook")

    if "approved" in event:
        return ctx.activity("fulfill", auth)

    ctx.activity("void", auth)
    raise WorkflowFailure(f"declined: {event}")

# your webhook endpoint, one line of glue:
#   engine.signal_workflow(f"capture-{order_id}", "psp", body)

The clock — trials that survive everything

A 14-day trial, a check, one last nudge, then archive. Three weeks of wall-clock time lived inside one function — through deploys, restarts, and engine upgrades — without a single row of scheduling state.

On the loom: the trial deadline is recorded as an absolute time. If the engine is down when it passes, the timer fires immediately on recovery. Late is impossible; lost is impossible.

Durable timersCrash recoveryZero infrastructure

Gotrial.go

func TrialToPaid(ctx sdk.Context, user []byte) ([]byte, error) {
	// 14 days. The deadline is on disk: deploys, restarts and even
	// engine upgrades don't reset the clock.
	ctx.Sleep("trial", 14*24*time.Hour)

	paid, err := ctx.ExecuteActivity("check-subscription", user)
	if err == nil && string(paid) == "yes" {
		return ctx.ExecuteActivity("grant-pro", user)
	}

	ctx.ExecuteActivity("send-last-call", user)
	ctx.Sleep("final-window", 72*time.Hour)

	return ctx.ExecuteActivity("archive-workspace", user)
}

	Queue + DB flags	workflowd	Temporal
Survives a crash mid-flow	✗ partial	✓	✓
Resumes without re-running work	✗	✓	✓
Infrastructure required	Redis + DB	none	DB cluster + services
Deploy artifact	your app	1 binary	several services
Time to first workflow	days of glue	minutes	a sprint
Horizontal HA	varies	Phase 4 (Raft)	✓
Multi-language SDKs	n/a	Go, TS, Python (+Java ref)	✓
Battle-tested at scale	—	✗ pre-alpha	✓

Honest status

The pattern, section by section

This is a build-in-public engineering project, currently pre-alpha. Weeks 1–10 of a 17-week plan are done. Don't put payroll on it yet.

✓

Phase 1 — Persistence & the core loop

History store, state machine, gRPC task queue, crash recovery + the Kill Test

✓

Phase 2 — Timers, signals, replay

Durable sleep, signals, deterministic replay of Go code, retries, Saga

✓

Phase 3 — Multi-worker & observability

Leases, heartbeats, Prometheus metrics, visibility API, dashboard

◐

Phase 4 — Replication with Raft

Leader election, log replication, snapshots, chaos tests — in progress next

○

Phase 5 — SDK polish & DX

Ergonomic public API, workflow versioning, testing framework, docs

Durable execution,
woven to last.

Every team rebuilds this badly

The DIY version breaks

The robust version is enormous

The whole engine is one pass of the shuttle

Read the cards

Replay

Schedule the next pick

Record the result

Append-only history

Deterministic replay

Crash = a no-op

Proven weaves, ready to run

The saga — charge, ship, never half-do it

The drip — onboarding that remembers where it was

The relay — park until the outside world answers

The clock — trials that survive everything

What you get today

Durable timers

Signals

Retries with backoff

Saga compensation

Leases & heartbeats

Metrics & dashboard

Any language

Not a Temporal replacement — a right-sized option below it

The pattern, section by section

Thread the needle