IBRAVRA Media Network
Comparisons • 12 min read

Temporal vs AWS Step Functions vs Cadence: The Durable Workflow Playbook

Temporal, Step Functions, and Cadence all promise durable execution — a workflow that survives crashes, retries, and waits lasting days. They charge for different things and fail in different places. This playbook prices one real workload three ways, runs the limits that actually decide, and gives the migration sequence that works.

By Enow A. Jovial • Published 2026-11-17
Temporal, AWS Step Functions, and Cadence solve the same problem — a multi-step process that must survive crashes, retries, and waits lasting days — but they charge for different things and fail in different places. Step Functions charges $0.000025 per state transition and caps Standard executions at one year and 25,000 history events. Temporal Cloud charges from $50 per million Actions and replays code from an event history that can run for years. Cadence charges nothing per execution — you run the cluster yourself under Apache 2.0. At one million executions a month, the same eight-step workflow costs $199.90 on Step Functions Standard, $400.00 on Temporal Cloud, and $3.08 on Step Functions Express, which cannot run anything longer than five minutes. Price never decides.

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.

AttributeTemporalAWS Step FunctionsCadenceAuthority
Programming modelWorkflow 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 executionYears (durable timers, schedules, Continue-As-New)Standard 1 year; Express 5 minutesYears (durable virtual memory)Temporal docs; AWS Step Functions quotas
List price, 1M executions/mo$400.00 at $50 per million ActionsStandard $199.90; Express $3.08$0 license + your own clusterTemporal 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:

SFN Standard=(8×1,000,000−4,000)×$0.000025=$199.90/month\text{SFN Standard} = (8 \times 1{,}000{,}000 - 4{,}000) \times \$0.000025 = \$199.90\text{/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:

Temporal Cloud=8×1,000,000×$501,000,000=$400.00/month\text{Temporal Cloud} = 8 \times 1{,}000{,}000 \times \frac{\$50}{1{,}000{,}000} = \$400.00\text{/month}
Temporal Cloud (volume tier)=8×1,000,000×$251,000,000=$200.00/month\text{Temporal Cloud (volume tier)} = 8 \times 1{,}000{,}000 \times \frac{\$25}{1{,}000{,}000} = \$200.00\text{/month}

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):

SFN Express=$1.00+1,000,000×2s×0.0625 GB×$0.00001667=$1.00+$2.08=$3.08/month\text{SFN Express} = \$1.00 + 1{,}000{,}000 \times 2\text{s} \times 0.0625\text{ GB} \times \$0.00001667 = \$1.00 + \$2.08 = \$3.08\text{/month}

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.

AWS Step Functions pricing example: a four-transition workflow executed 100,000 times costs $9.90 after the 4,000 free transitions, at $0.000025 per state transition
AWS Step Functions pricing example: a four-transition workflow executed 100,000 times costs $9.90 after the 4,000 free transitions, at $0.000025 per state transition

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 two most expensive mistakes in this comparison are both silent. The first is building a long-running workflow on Step Functions Express and discovering the five-minute cap in production, when the execution fails with a States.Timeout error and the only fix is a rebuild. The second is building a high-volume workflow on Temporal Cloud without counting Actions first: every Workflow, Activity, Timer, Signal, Query, and Schedule is a billable Action, and a chatty workflow that polls with timers can generate ten times the Actions its author expected. Count the Actions per execution on paper before you commit.
Before you choose, run the same workflow on two engines for a week and compare the real bills, not the list prices. Temporal Cloud starts with $150 in credits for 90 days and no base monthly fee, and Step Functions Standard gives you 4,000 free state transitions a month forever. A week of real executions tells you the Actions-per-execution and transitions-per-execution figures that no pricing page can, and those two numbers — not the headline rate — decide the bill.

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

"Every team I have watched pick a workflow engine picked it for the happy path and regretted it on the failure path. The happy path is the demo. The failure path is the product: the worker dies at 2 a.m., the deploy lands mid-workflow, the customer waits three days for an approval. Choose the engine whose worst day you can explain to your customer, and whose bill you counted before you committed — not the one with the cheapest headline rate."
— Enow A. Jovial, Founder & Chief Executive Officer

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.