What durable execution actually buys you
Most backend code assumes the process stays alive. A checkout flow charges a card, reserves inventory, sends a confirmation, and books a shipment — four calls to four systems, any of which can fail, time out, or return an ambiguous answer. The usual fix is plumbing: a queue, a state table, a cron job, and a runbook. Durable execution removes the plumbing by making the workflow itself durable: the platform records every step in an event history, so a crash, a deploy, or a network partition resumes the workflow exactly where it left off.
Temporal states the model plainly in its documentation: each workflow execution emits commands and processes events, recorded in an Event History that is the source of truth for everything that has already happened. When the workflow continues, Temporal does not restore memory from a snapshot. It starts the workflow code from the beginning, replays the Event History step by step, and uses that history to guide the code back to the exact state it was in before the pause. Activities — the calls that touch the outside world, such as API calls, database queries, LLM invocations, and file I/O — run once. Their results are recorded in the history and reused during replay, never recomputed. That replay is why workflow code must be deterministic: a direct call to Date.now() or a random number would return a different value on replay, so Temporal provides replay-safe versions of time, timers, and randomness through the workflow context.
The three engines in one paragraph each
Temporal is the commercial open-source platform built by Samar Abbas and Maxim Fateev, who founded Temporal Technologies in 2019 after building Cadence at Uber. GeekWire reported in February 2026 that the company had raised a $300 million Series D at a $5 billion valuation, and that customers include OpenAI and Replit.
AWS Step Functions is the managed workflow service inside AWS, and it comes in two flavours that behave like different products. Standard Workflows are the durable kind: executions run up to one year, history is retained 90 days after close, and you are charged per state transition. Express Workflows are the high-volume kind: executions run at most five minutes, there is no retained history, and you are charged per request plus duration.
Cadence is the engine Temporal grew out of. It is the open-source workflow system built at Uber, now a Linux Foundation project, running the same fault-oblivious stateful model: a durable virtual memory that preserves the full application state across host and software failures. Its official SDKs are Go and Java; the backend stores history in Cassandra, MySQL, or Postgres. The server is Apache 2.0 licensed, so the software costs nothing and the bill is the cluster you run plus the engineers who operate it. Cadence has no hosted cloud and no per-execution meter — and no one to call at 2 a.m. but your own team.
| Attribute | Temporal | AWS Step Functions | Cadence | Authority |
|---|---|---|---|---|
| Programming model | Workflow as code (Go, Java, Python, TypeScript, .NET, PHP, Ruby, Rust) | JSON state machine (Amazon States Language) | Workflow as code (Go, Java official; Python, Ruby community) | Temporal docs; AWS docs; Cadence docs |
| Longest execution | Years (durable timers, schedules, Continue-As-New) | Standard 1 year; Express 5 minutes | Years (durable virtual memory) | Temporal docs; AWS Step Functions quotas |
| List price, 1M executions/mo | $400.00 at $50 per million Actions | Standard $199.90; Express $3.08 | $0 license + your own cluster | Temporal pricing; AWS pricing (worked below) |
The cost math: one workload, three bills
The workload is an order-fulfilment workflow: one workflow start, five activities (charge, reserve, confirm, ship, ledger), and two timers (a 15-minute payment hold and a 24-hour dispatch window) — eight billable units per execution, one million executions a month.
For Step Functions Standard, the meter is the state transition — one per workflow step. The price in US East is $0.000025 per transition, with 4,000 free a month:
For Temporal Cloud, the meter is the Action: a Workflow, an Activity, a Timer, a Signal, a Query, or a Schedule. Counting one Action for the workflow start, one per Activity, and one per Timer gives eight Actions per execution. Pay-as-you-go starts at $50 per million Actions, with self-service volume pricing down to $25 per million:
For Step Functions Express, the meter is the request plus duration: $1.00 per million requests, and $0.00001667 per GB-second, rounded up to the nearest 100 ms and charged in 64 MB memory chunks. Assume a two-second average execution and the minimum 64 MB billed memory (0.0625 GB):
Three bills, one workload: $199.90, $400.00, and $3.08. The Express number is the trap: sixty-five times cheaper than Standard, and unable to run this workload, because the 24-hour dispatch timer alone exceeds the five-minute maximum execution time. Express is for high-volume, short-lived orchestration; the moment a workflow waits, it stops being an Express workload.
Temporal Cloud's storage line is easy to miss. Active storage — the event history of open workflows — costs $0.042 per GB-hour, and retained storage for closed workflows costs $0.00105 per GB-hour. A fleet of long-running workflows pays a storage bill on top of the Actions bill. Step Functions Standard has no storage line, but it has a harder edge: an execution history that reaches 25,000 events fails outright, and a closed execution's history disappears after 90 days. If your audit requirement is six months of history, Step Functions Standard needs an external archive you build yourself.
Cadence has no meter, so the honest way to price it is as a formula, not a number. The software is free under Apache 2.0. The cost is the cluster — typically a multi-node deployment with a Cassandra, MySQL, or Postgres history store — plus the engineering time to upgrade it, back it up, and answer the page when it stops. Price Cadence by the on-call rota, not by the licence.
The limits that decide for you
Duration is the first filter. If any workflow waits longer than five minutes, Express is out, and the choice narrows to Temporal, Cadence, or Step Functions Standard. If any workflow waits longer than a year, Step Functions Standard is out too: its one-year maximum execution time fails the execution with a States.Timeout error, and the fix is restructuring into chained executions.
History is the second filter. Step Functions Standard caps a single execution at 25,000 history events and keeps the history for 90 days after the execution closes. A chatty workflow that polls, retries, or loops through hundreds of items can hit 25,000 events before it finishes — and the failure mode is the execution dying, not a warning. Temporal keeps the full Event History for replay; Cadence keeps it in your own database.
Determinism is the third filter, and it cuts against the code-based engines. Temporal and Cadence replay workflow code from the beginning to rebuild state, so the code must make the same decisions given the same history. A direct call to Date.now(), a random number, or a network call outside an Activity returns a different value on replay and can send the workflow down a different path. The fix is discipline: read time from the workflow context, capture randomness once, and put every outside call inside an Activity, where the result is recorded once and reused. Step Functions has no version of this problem — the state machine is data, not code — but its definition is capped at 1 MB, and a complex workflow in JSON is hard to test and easy to break.
When each engine wins, and who should not use it
Temporal wins when the workflow is long-lived, branchy, and owned by application developers who want to write it in Go, Java, TypeScript, or Python and test it with the same tools they test everything else. It wins for AI agent orchestration: an agent session that runs for hours, calls tools, waits for a human, and resumes the next day is exactly a durable workflow. It loses on price at list rates for high-volume, short-lived workloads, where Step Functions Standard is half the per-unit cost and Express is a rounding error.
Step Functions wins when the system already lives in AWS, the workflows are short or medium-lived, and the team would rather write JSON than operate a cluster. It wins on the meter: $0.000025 per transition is the cheapest per-unit price of the three metered options, and the 4,000 free transitions a month mean a small system can run for nothing. It wins for event-driven glue, where the workflow is a sequence of AWS service calls and the state machine is the documentation. It loses the moment a workflow needs to wait a year, keep a history past 90 days, or leave AWS.
Cadence wins when the team already operates distributed infrastructure, when the workflow volume is high enough that per-execution metering would dominate the bill, and when the organisation cannot accept a vendor-operated control plane for its core processes. It loses for any team without an on-call rotation, a database operator, and the appetite to debug a workflow engine at 2 a.m.
The migration sequence that actually works
Step 1 — Pick one workflow, not the platform. Choose a single process that hurts today: the onboarding flow that loses state on deploy, or the payment flow that double-charges on retry.
Step 2 — Count the billable units on paper. For Temporal, count Actions per execution: one for the workflow start, one per Activity, one per Timer, Signal, and Query. For Step Functions, count state transitions per execution, including retries.
Step 3 — Prove the long wait. Write the workflow with its real timer — the 24-hour dispatch window, the 30-day trial, the approval that takes a week — and run it on the engine you are evaluating.
Step 4 — Test the failure, not the happy path. Kill the worker mid-execution, deploy new code mid-workflow, and restart the database. The engine should resume exactly where it left off.
Step 5 — Check the history after the fact. Close an execution and come back in 100 days. Can you still read what happened, step by step?
Step 6 — Decide on the bill, the rota, and the exit. The bill is the metered price at your real volume. The rota is who answers the page; the exit is what it costs to leave.
For the surrounding architecture, the Apache Kafka vs RabbitMQ vs Redpanda streaming guide covers the event-streaming layer that usually feeds these workflows, the Qdrant vs Pinecone vs pgvector architecture guide covers the retrieval layer that AI agent workflows read from, and the EKS vs GKE vs AKS managed Kubernetes guide covers the cluster that self-hosted Temporal or Cadence usually runs on. Run the workload's monthly cost through the ROI calculator with your own executions-per-month figure before you sign anything.
Founder & CEO Insight — Enow A. Jovial
Temporal vs Step Functions vs Cadence: the launch checklist
- [x] Count the billable units: Actions per execution on Temporal, state transitions per execution on Step Functions, including retries.
- [x] Prove the long wait: Run the workflow with its real timer, not a five-minute test.
- [x] Test the failure path: Kill the worker mid-execution and deploy mid-workflow; the engine must resume exactly where it left off.
- [x] Check the history at 100 days: Confirm you can still read a closed execution's history, or build the archive Step Functions Standard does not provide.
- [x] Price the storage line: Temporal Cloud active storage at $0.042 per GB-hour is a separate bill from Actions.
- [x] Decide the rota and the exit: Know who answers the page and what it costs to leave.
- [x] Compare on real bills: Run one workflow on two engines for a week on the free tiers and compare the actual invoices.
