Temporal (workflow engine)

Temporal is an open-source workflow orchestration platform that lets developers write multi-step distributed business processes as ordinary code and guarantees they will complete even when servers crash, networks fail, or deployments are interrupted. In ecommerce, Temporal is used to orchestrate OMS order sagas, subscription billing, carrier routing, payment flows, and inventory reservation — any process that spans multiple services over seconds, hours, or days.

How it works

Temporal's core model separates two concerns (temporal.io, as-of 2026-08-30):

Workflows contain deterministic orchestration logic — no external I/O, no randomness. Every state change is written to an immutable event history inside the Temporal server. If a worker crashes mid-run, any other worker picks up from the last recorded event with no data loss and no developer intervention required.

Activities are the side-effecting functions — calling carrier APIs, charging a payment method, reserving inventory in a WMS. Temporal wraps activities with configurable retry policies, timeouts, and exponential backoff automatically.

Workers are stateless processes that poll Task Queues and execute both workflows and activities. Because workers are stateless and pull-based (they poll outward; nothing pushes to them), horizontal scaling is straightforward — adding capacity in a new environment or cloud region means starting the same worker image with the correct queue name.

Component	Role
Workflow code	Deterministic orchestration; no I/O
Activity code	Side effects — API calls, DB writes
Worker	Polls Task Queue; executes both
Temporal Server	Persists event history; hands out tasks
Task Queue	Decouples server from workers
Client	Starts workflows; sends Signals; reads Queries

Source: dev.to/hassan314159 — Simply Order Part 2 (2025-09-04)

Hard limits (as-of 2026-08-30)

Limit	Value
Events per workflow execution	51,200
Payload per workflow execution	50 MB
Child workflows per parent	1,000

Workflows that approach these limits must use continue-as-new — a built-in primitive that completes the current execution and starts a fresh one, carrying forward only the minimal required state. Subscription billing workflows (which run indefinitely, one billing cycle per loop) must use continue-as-new at least monthly. Source: automationatlas.io (2026-07)

A non-obvious constraint: workflow code must be deterministic. Side effects (datetime, random number generation) require SDK-provided escape hatches. Logging libraries that inspect local variables on exceptions can violate this constraint and cause replay failures. Source: h4s.one practitioner blog (2024-02)

Ecommerce use cases

Order saga (OMS)

The canonical Temporal ecommerce pattern implements an order state machine as an orchestration Saga Pattern:

Order Created → Payment Processed → Inventory Reserved → Order Shipped
                    ↓ (on failure)         ↓ (on failure)
              Cancel Order            Release Inventory
              Restore Inventory

A full state machine from a published tutorial: OPEN → PENDING → INVENTORY_RESERVED → PAYMENT_AUTHORIZED → COMPLETED, with compensation states INVENTORY_FAILED, PAYMENT_FAILED, FAILED_UNKNOWN. Compensating activities (e.g. releaseInventory, voidPayment) must be idempotent and must not have a ScheduleToCloseTimeout set — they should retry until they succeed. Source: dev.to/hassan314159 (2025-09-04); docs.temporal.io/design-patterns/saga-pattern (copyright 2026)

Temporal's July 2026 builder spotlight featured a full-stack ecommerce demo where every state transition from cart to fulfillment and delivery is a Temporal workflow — no message queues, cron jobs, or separate saga orchestrators. Built on Next.js, TypeScript SDK, Cassandra, and Elasticsearch. Source: temporal.io/blog/durable-digest-july-2026 (2026-07-30)

Subscription billing

ShareChat rebuilt its subscription billing engine on Temporal (Go SDK, Temporal Cloud), replacing four cron jobs with a hierarchy of durable workflows. The migration (November 2025 to April 2026) raised the debit-attempt success rate from ~95% to 99.9%+, processing ~50 million billing transactions and ~450 million total workflow actions per month (as-of 2026-07-28). Temporal's durable timers enforce regulator-mandated notify-to-collect delays and per-notification retry caps — making regulatory sequencing a guarantee of the execution model rather than fragile scheduling logic. Source: temporal.io/resources/case-studies/sharechat (2026-07-28)

Logistics and carrier orchestration

SMILe (Shree Maruti Integrated Logistic Limited) uses Temporal as its end-to-end booking orchestration layer, dynamically routing shipments across courier, hyperlocal, and ecommerce fulfillment paths based on pincode serviceability, SLA, cost, and vehicle type — replacing fragile distributed coordination that required manual recovery after partial failures. Source: temporal.io/resources/case-studies/shree-maruti-integrated-logistic-limited-smile (2026-06-17)

Maersk replaced its payment orchestrator with a Temporal Workflow and rebuilt its booking flow (a decades-old OMS spanning container shipping, inland, and air cargo). Capabilities gained: dynamic billing (instant or end-of-workflow), human-in-the-loop document upload steps as child workflows, and long-running workflows spanning days to weeks for cross-border transfers. Maersk reported new features now take 5–10 days to deliver versus the previous 60–80 days (6–16x faster) (as-of 2024-09-09). Source: temporal.io/resources/case-studies/maersk (2024-09-09)

Payment orchestration

Temporal's CPO characterises "business process applications" (which includes payment flows) as defined by four properties: external dependencies you cannot control, valid-state management (only certain states are legal at any moment), schedule or deadline enforcement, and steps separated by seconds to years. All four become dramatically cheaper to implement in Temporal than with a classical database + queue + external scheduler stack. Source: youtube.com — Temporal Technologies "Top 3 Use Cases" (2022-03-04)

A common ecommerce payment pattern: the first leg (authorize transaction, return result to client) must run in milliseconds; the second leg (bookkeeping, waiting for external authorization, capturing the transaction days later) can take as long as needed — Temporal manages both halves inside a single durable workflow. Source: youtube.com — Retool Replay 2023 (2023)

Relation to the Saga Pattern

Temporal implements orchestration sagas — a centralized coordinator (the Workflow) manages the transaction flow, preferred for complex workflows needing clear visibility. This contrasts with choreography sagas, where each service listens for events and independently triggers subsequent actions.

Approach	Consistency	Coupling	Scalability
Orchestration Saga (Temporal)	Eventual	Loose	High
Choreography Saga	Eventual	Very loose	High
Two-phase commit	Strong ACID	Tight	Low
Local transaction	Strong ACID	None	Single service

Source: docs.temporal.io/design-patterns/saga-pattern (copyright 2026)

The Saga Pattern documentation notes that orchestration sagas are a good fit when long-running transactions span hours or days and when eventual consistency is acceptable. It explicitly states the pattern is "not a good fit" for operations requiring strong ACID consistency or where compensating transactions cannot be defined. Source: docs.temporal.io/design-patterns/saga-pattern

Temporal vs alternatives

AWS Step Functions

Dimension	Temporal	AWS Step Functions
Authoring	Code-first (Go, Java, Python, TypeScript, .NET, PHP)	Amazon States Language (JSON/YAML visual)
Where it runs	User-managed workers; any cloud	AWS-managed; AWS-native
Activity scope	Any function call	AWS SDK, Lambda, HTTP API only
Timer granularity	Down to every second	Minimum every minute (as-of 2026-01-12)
Managed cost	$100+/month (Essentials plan)	Pay-per-transition

Source: readysetcloud.io (2024-07-03, updated 2026-01-12)

Camunda

The Camunda vs Temporal split is described as cultural rather than technical: engineering-led teams choose Temporal (workflow lives in Git as code); product/compliance-led teams choose Camunda (BPMN diagram is the deliverable). Source: automationatlas.io (2026)

Data pipeline tools

Kestra, Airflow, Prefect, and Dagster are purpose-built for data pipelines, not application workflow orchestration. For microservices and application teams needing durable execution embedded within application logic, the relevant comparators are Temporal, Netflix Conductor/Orkes, AWS Step Functions, and Inngest/Trigger.dev. Source: kestra.io (2026 reference)

Deployment and pricing (as-of 2026-08)

Self-hosted: free under MIT licence. Self-hosting requires Postgres (two databases); Elasticsearch and Kafka are not required in current versions. Teams report running self-hosted on ECS with 1 vCPU / 2 GB RAM at under 10% load for hundreds of workflows per minute. Source: h4s.one (2024-02)

Temporal Cloud (as-of 2026-07):

Plan	Monthly minimum	Included actions	SLA
Essentials	$100	1M actions	99.9%
Business	$500	2.5M actions	Higher

History retention: up to 90 days. Reducing per-namespace retention from default to 30 days can reduce storage costs materially (one reported example: 480 GB → 41 GB, saving ~$190/month). Source: automationatlas.io (2026-07)

July 2026: Temporal shipped Serverless Workers for GCP Cloud Run in pre-release, which automatically invokes, scales, and shuts down workers based on workload volume — scaling to zero when idle. Source: temporal.io/blog/durable-digest-july-2026 (2026-07-30)

Adoption and learning curve

Temporal reports 2,000+ companies running in production (as-of mid-2026). Published production users include Snap, Box, Stripe, HashiCorp, Coinbase, Datadog, Netflix, ANZ Bank, DigitalOcean, DoorDash, Instacart, Block/Afterpay, Mollie, Maersk, and ShareChat. Source: temporal.io; temporal.io/blog/mastering-saga-patterns (2025-01-31)

Median time-to-first-production-workflow across 7 deployments (2025–26): 11 days for teams comfortable with Go or Python; 26 days for teams coming from Airflow. Workflow versioning is the most cited deploy hazard — skipping GetVersion() calls on in-flight workflows during deploys can break determinism. Source: automationatlas.io (2026-07)

The 2026 review characterises the learning curve as steep for developers unfamiliar with distributed systems concepts; self-hosting demands ongoing infrastructure management. Source: youtube.com — 2026 review (2026-03-03)

Key terms

Term	Meaning
Durable Execution	Temporal's core guarantee: workflow state survives any failure by persisting event history
Workflow	Deterministic, stateful orchestration code; no side effects
Activity	Side-effecting function (API call, DB write) with automatic retry
Worker	Stateless process that polls a Task Queue and executes workflows/activities
Task Queue	Named queue that decouples Temporal server from workers
Signal	External event sent to a running workflow (e.g. "payment confirmed")
Query	Synchronous read of a running workflow's state
continue-as-new	Closes a workflow execution and starts fresh, carrying forward minimal state; used to manage event history limits
Compensating transaction	Activity that undoes a previously completed step (e.g. releaseInventory)