Comparison with other workflow engines

gobank-workflow is small by design: a run record per instance, a step record per unit of work, two runners, a definitions registry and a versioned schema. This page sets it against the Go workflow libraries and the larger orchestration systems as they stood on 2026-10-04, to show what is deliberately absent and what might be worth adding. Versions and licences change; the figures are a snapshot and each system's own docs are the source of truth.

Why this stays a component

In the gobank model bank every table belongs to one component and other code reads it through that component's contract view (ADR-0001). The workflow runs and steps are bank data: the DB explorer shows them beside accounts and postings, the step results carry opening and closing balances in the ledger's own units, and the schema moves with the rest of the bank through gobank-db expand/contract migrations. Every engine below keeps instance state somewhere else, in its own history store, in a Kafka log, in a server's RocksDB, or in Postgres tables shaped by the engine, and none compiles to WASM, so none could run inside the browser demo on pglike. Adopting one would move the workflow component's data outside the bank's database or outside the contract-view rule. That is the reason to stay separate, and it is also the reason the comparison is worth keeping: the engines below are where the missing features have already been designed once.

The landscape

The systems fall into three groups by what you run and how a workflow is written.

System Group Workflow is written as You run Instance state lives in Licence Go
gobank-workflow library Go: a Definition with named steps; RunDaily, RunPipeline nothing extra your database (pglike, Postgres, SQLite) MIT native
go-workflows library Go: deterministic function replayed from history nothing extra SQLite, MySQL, Postgres, Redis MIT native
DBOS Transact Go library Go: function with checkpointed steps nothing extra (paid console optional) Postgres, SQLite MIT native
luno/workflow library Go: typed status machine, step per transition nothing extra SQL record store + Kafka or in-memory stream BSD-3 native
River library Go: job kinds; DAG workflows are River Pro (closed source, paid) nothing extra Postgres, SQLite MPL-2.0 core native
asynq library Go: tasks; no workflow layer Redis Redis MIT native
Temporal server, code Go: deterministic function replayed from history server + Postgres/MySQL/Cassandra (+ Elasticsearch at scale) + UI server's history store MIT first-class SDK
Cadence server, code as Temporal four services + Cassandra/SQL server's store Apache-2.0 (CNCF) first-class SDK
Restate server, code Go: journaled handlers; services, keyed objects, workflows one server binary server's RocksDB BSL-1.1 server, MIT SDK first-class SDK
Inngest server, code Go: event-triggered function with memoised steps server or cloud server (SQLite/Postgres + Redis) SSPL server, Apache-2.0 SDK first-class SDK
Hatchet server, code Go: tasks and DAGs; durable tasks checkpoint waits engine + Postgres engine's Postgres MIT first-class SDK
Dapr Workflow server, code Go: replayed orchestration (durabletask) Dapr sidecar + state store Dapr state store Apache-2.0 first-class SDK
LittleHorse server, graph Go DSL compiled to a node graph on the server JVM server + Kafka Kafka + RocksDB AGPL server, Apache-2.0 SDK first-class SDK
Conductor server, declarative JSON definition; Go builder available JVM + Redis/Postgres + Elasticsearch/OpenSearch server's store Apache-2.0 SDK (Orkes)
Argo Workflows server, declarative YAML CRD; one pod per step Kubernetes Kubernetes API (+ archive DB) Apache-2.0 typed client
Camunda 8 / Zeebe server, BPMN BPMN 2.0; job workers in code 3+ brokers + Elasticsearch/OpenSearch + Identity brokers' Raft log source-available, paid in production REST or community gRPC client
Flowable library (Java), BPMN BPMN 2.0, CMMN, DMN JVM + RDBMS your RDBMS, engine's tables Apache-2.0 engine REST only
Spring Batch library (Java) Java: job of chunked or tasklet steps JVM your RDBMS, BATCH_* tables Apache-2.0 none
Kestra server, declarative YAML flow; Go only as a script task JVM + Postgres server's DB Apache-2.0 core script runner
Windmill server, declarative visual or JSON flow of scripts; Go as a script language Rust server + Postgres server's Postgres AGPL + proprietary script runner

Two execution models dominate. Replay engines (go-workflows, DBOS, Temporal, Cadence, Restate, Inngest, Dapr) record the result of each side-effecting step and re-run the workflow function from the top on recovery, which lets ordinary code sleep for a month or wait for an event, at the price of a determinism rule on the workflow body. Recorded-step engines (gobank-workflow, luno/workflow, Spring Batch, the BPMN engines, the declarative orchestrators) keep an explicit record of where an instance is and resume from it; the code has no determinism rule but every wait has to be modelled as a stored state. gobank-workflow is in the second camp, and the closest relatives are the three in the next section.

Feature matrix: Go libraries

Y means built in, P means partial or a documented pattern, N means absent, U means not confirmed from the project's own documentation.

Feature gobank-workflow go-workflows DBOS Go luno/workflow River (core)
Instance keyed by business key, duplicate refused Y, (type, date, key) unique Y, caller-chosen instance id Y, workflow id Y, foreign id Y, unique jobs
Completed instance is never re-run Y Y Y Y P, unique by state
Retry of a failed instance keeps its identity Y, restart in place Y Y Y Y, same job
Resume from the failed step, not the start Y, pipeline only; daily reprocesses every account Y, replay Y, step checkpoints Y, status machine N
Per-step retry with backoff N, caller re-runs Y Y Y Y
Durable timer or sleep N Y Y Y, timeout steps P, scheduled jobs
External event into a running instance N Y, signals Y, send/recv, events Y, callbacks, connectors Pro only
Parallel steps, fan-out N Y Y Y, parallel consumers Y, queues; DAG is Pro
Child workflows N Y Y N Pro only
Compensation (saga) N N N N N
Change definition while instances in flight N, steps matched by name N Y, version, patch, fork P n/a
Schedule, cron N, caller drives N Y Y Y, periodic jobs
Catch-up over missed periods Y, CatchUp N N N N
Attempt history kept N, failed steps deleted on retry Y, full history Y Y, event log Y, errors list
Definition visible as data Y, registry, d2 diagrams P, diagnostics UI N Y, Mermaid N
UI Y, demo app pages Y, diagnostics paid console Y Y, River UI
Metrics, tracing N Y, OTel U Y, Prometheus Y, OTel
Test support Y, memory store, storetest contract Y, mocks, timer skipping P Y, testing package Y, rivertest
Schema versioned with the host database Y, gobank-db migrations N, own schema N, own schema N, own schema N, own migrations
Runs in the browser (WASM, pglike) Y N N N N

Feature matrix: larger systems

Feature gobank-workflow Temporal Restate Camunda 8 Flowable Conductor LittleHorse Spring Batch
Instance keyed by business key, duplicate refused Y Y, id reuse and conflict policies Y, workflow key P, message correlation P, business key not unique Y in Orkes; U in OSS Y, unique run id Y, identifying job parameters
Completed instance is never re-run Y Y, RejectDuplicate or AllowDuplicateFailedOnly Y P P P Y Y, JobInstanceAlreadyComplete
Resume from the failed step Y, pipeline Y Y Y Y Y Y Y, last committed chunk
Per-step retry with backoff N Y Y Y P, fixed count Y Y Y, item level
Durable timer N Y Y Y, timer events Y Y, wait task Y N
External event into a running instance N Y, signal, update Y, awakeables, promises Y, messages Y Y Y, external events, interrupts N
Parallel steps N Y Y Y, gateways, multi-instance Y Y, fork/join Y, threads Y, split, partitioning
Child workflows N Y Y Y, call activities Y Y Y P, job step
Compensation (saga) N P, coded Y, documented pattern Y, BPMN compensation Y P, failure workflow Y, failure handlers N
Change definition while instances in flight N Y, patching, worker versioning Y, deployment pinning Y, instance migration Y, migration service Y, versioned definitions Y, versions, migration plans N
Schedule, cron N Y, Schedules with overlap and catch-up policy N P, timer start P, timer start Y U N, external
Human task N P, wait for signal P Y, Tasklist Y, OSS has no UI P Y N
Attempt history kept N Y Y Y Y Y Y Y, one JobExecution per attempt
UI Y, demo app Y Y Y commercial only since v7 Y Y N
Metrics, tracing N Y Y Y P P Y Y, Micrometer
Test support Y Y, time skipping, replayer Y, Testcontainers Y, Java only Y, Java only P U Y, Java only
Smallest production footprint one process, one database server + DB + UI one binary 3 brokers + search cluster JVM + RDBMS JVM + Redis + search JVM + Kafka JVM + RDBMS

Where finance use is documented: Temporal names ANZ, JPMorgan Chase, Macquarie, Coinbase, Klarna and Checkout.com; Flowable publishes tier-one bank case-management studies; Camunda markets to banking; Spring Batch's reference manual uses an end-of-day job keyed by business date as its worked example.

The three closest relatives

Spring Batch is the direct ancestor of RunDaily. Its JobInstance is a job plus its identifying parameters, and the manual's example is an EndOfDayJob with schedule.Date as that parameter: one instance per business date, exactly our (type, date) key. Each attempt is a separate JobExecution, a completed instance cannot be restarted, and a failed one restarts from the last committed chunk because readers persist their position in an ExecutionContext. The two things it has that we do not are the attempt record and the chunk-level resume; the first matters for audit, the second is the mechanism the gobank roadmap's start-of-day workflow needs when it says the pass over every account "resumes after a restart from the rows already written".

Temporal solves the idempotency question we solved with a unique index by policy on the workflow id. AllowDuplicateFailedOnly is precisely RunDaily's contract: a completed id is refused, a failed one may be run again. Its conflict policy for an id that is still running (Fail, UseExisting, TerminateExisting) names a case we have not handled, and its Schedules object (overlap policy, catch-up window, backfill) is the mature form of CatchUp. Everything else it offers comes with the replay model and a server, which is the part we are not buying.

luno/workflow is the nearest Go library in spirit: no replay, a typed status machine over a SQL record store, idempotent on a foreign id, with timeouts, callbacks, cron and a Mermaid diagram of the definition. It reached v1.0 on 2026-09-30. It shows what a recorded-step Go library grows into if it keeps going, and its event-stream dependency is the point at which it stops fitting a one-database component.

Gaps and candidates

Each row is a feature the engines above have and this one does not. The decision is whether the bank's own workflows need it; the candidate is the smallest shape that fits the current model.

Gap Who has it well Needed by Candidate shape Priority
A running instance can be restarted by a second runner: RunDaily restarts any non-completed run, including running Temporal conflict policy, Spring Batch JobExecutionAlreadyRunning stage 8 of the gobank roadmap, several processes and one workflow runner ErrAlreadyRunning from RestartRun unless the run is stale; a heartbeat_at column to judge stale now
Attempt history is lost: a retry deletes the failed steps Spring Batch JobExecution, every replay engine audit of a failed end-of-day an attempt number on workflow_steps, kept across retries, with the instance page showing the last attempt by default now
Daily run reprocesses every account; pipeline resumes but daily does not Spring Batch chunk restart, DBOS steps roadmap stage 3d, resume mid-pass record each account's step as it completes and skip completed ones on retry; the pipeline already does this by step name with stage 3
No schedule or overlap policy; the caller decides when to run Temporal Schedules, Argo CronWorkflow production runner a schedules table and a tick: next due date, skip if the previous run is still running; CatchUp is already the backfill with stage 8
No per-step retry with backoff all network stages of the release pipeline Stage.Retry with attempts and backoff, recorded as attempts of the step when it hurts
No durable wait for an external event Temporal signals, Restate awakeables, BPMN messages payment settlement, awaiting a scheme response a waiting run status and a Store.Signal that records the event and wakes the run with payments
No parallel steps all pacing the account pass, not throughput, is the current need leave; the roadmap paces the pass over the day not planned
No compensation Camunda, LittleHorse, Restate a release that fails after push origin an optional Stage.Undo run in reverse for completed stages; worth it only if a half-shipped release is observed not planned
No definition versioning Temporal, LittleHorse, BPMN engines instances that outlive their code: the instance page, and purging old runs a revision (hash of the step names) recorded on the run, so an old instance renders from what it recorded; no migration (roadmap "Purpose and revision") now
No human task Camunda, Flowable, LittleHorse four-eyes approval on a payment or release a step whose completion is a signal from the staff UI, once signals exist after signals
No metrics all servers operations counters per definition and status, exported where the bank exports the rest with stage 8

What this engine has that the others do not is the other half of the decision: its state is bank data under the contract-view rule, its schema is versioned with the bank's, its step results are domain figures rather than opaque payloads, its definitions are drawn from the code they describe, and the whole thing runs in a browser on pglike. Those are the properties any addition from the table above has to keep.

Sources

Each system's figures were read from its own repository, releases and documentation on 2026-10-04. The load-bearing pages: