/weave

Workflow Engine Selection Guide

Purpose: Selection guide for workflow engines. Read when: Picking the right workflow engine for a project.

Engine Comparison Matrix

Note: Cadence (Uber's predecessor to Temporal) is effectively superseded by Temporal for new projects. Source: temporal.io

Selection Decision Tree

What kind of workflow is it?
├── Frontend / in-process state management
│   └── XState v5 (Actor model, createActor)
├── Data pipeline / ETL
│   ├── Python-heavy → Airflow or Prefect
│   └── Stream integration → Kafka Streams (see Stream agent)
├── Serverless / event-driven
│   ├── AWS-only → Step Functions
│   └── Multi-cloud / Next.js → Inngest or Trigger.dev
├── AI agent workflows (durable execution)
│   ├── LangGraph — stateful graph-based agents, human-in-the-loop
│   ├── Temporal + OpenAI Agents SDK — durable long-running agents
│   └── DBOS + OpenAI Agents SDK — Postgres-backed durable agents
└── General business workflow
    ├── Already on AWS → Step Functions
    ├── Want minimal infra overhead + Postgres only → DBOS Transact
    ├── Want durable async/await with service-boundary isolation → Restate
    ├── Multi-cloud / high availability
    │   ├── Want managed service → Temporal Cloud
    │   └── Self-hosting OK → Temporal OSS
    └── Simple event chain → Inngest

Temporal

Strengths

• Language-native workflow definitions (code is the workflow)
• Strong durability guarantees (replay-safe execution)
• Signal/Query/Update for external interaction with workflow state
• Child Workflow and Continue-as-new support long-running workflows

Best For

• Long-running business processes (days to months)
• Complex compensation and retry logic
• Microservice-to-microservice orchestration

Template

TEMPORAL_WORKFLOW:
  name: "[WorkflowName]"
  task_queue: "[queue-name]"
  workflow_execution_timeout: "30d"
  activities:
    - name: "[ActivityName]"
      start_to_close_timeout: "30s"
      retry_policy:
        initial_interval: "1s"
        backoff_coefficient: 2.0
        maximum_attempts: 5
        non_retryable_error_types: ["BusinessError"]
  signals:
    - name: "[SignalName]"
      description: "[External trigger]"
  queries:
    - name: "[QueryName]"
      description: "[State inspection]"

AWS Step Functions

Source: aws.amazon.com — Distributed Map Feb 2025, aws.amazon.com — Distributed Map Sep 2025

Strengths

• Native integration with AWS services (Lambda, SQS, DynamoDB, etc.)
• Declarative workflow definitions via ASL
• Two execution modes: Express (high-volume, at-least-once) and Standard (long-running, exactly-once)
• Distributed Map for large-scale parallel data processing:
  • Feb 2025: JSONL, semicolon/tab-delimited formats, output transformations
  • Sep 2025: Athena manifest, Parquet, S3ListObjectsV2 prefix iteration, JSON array extraction, observability metrics (Approximate Open Map Runs Count)
• Built-in error handling and retries

Best For

• AWS-centric architectures
• Serverless workflows
• Orchestrating Lambda functions
• Large-scale parallel data processing (Distributed Map)

Template

{
  "Comment": "[WorkflowDescription]",
  "StartAt": "[FirstState]",
  "States": {
    "[StateName]": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...",
      "Retry": [{
        "ErrorEquals": ["States.TaskFailed"],
        "IntervalSeconds": 2,
        "MaxAttempts": 3,
        "BackoffRate": 2.0
      }],
      "Catch": [{
        "ErrorEquals": ["States.ALL"],
        "Next": "[ErrorHandler]"
      }],
      "Next": "[NextState]"
    }
  }
}

Restate

Source: restate.dev, pkgpulse.com — inngest-vs-trigger-dev-v3-vs-restate-2026

Strengths

• Durable async/await baked into service boundaries via an opt-in SDK — developers choose which code paths are durable
• Strongly-typed RPC between services with built-in retry and exactly-once semantics
• Lightweight compared to Temporal: no external orchestrator cluster required

Best For

• Microservice orchestration where workflow correctness must be enforced at service boundaries
• TypeScript, Java, Go, and Rust backends
• Teams wanting Temporal-class durability without the operational overhead

DBOS Transact

Source: dbos.dev/dbos-transact, dbos.dev — March 2026 updates

Strengths

• Postgres-backed durable execution: workflow state is checkpointed in Postgres — no separate orchestration cluster
• Minimal integration footprint: a 110-LoC app requires only ~7 lines of change vs. >100 for Temporal
• Supports TypeScript, Python, Java, Go, and Kotlin (as of March 2026)
• Workflow patching (March 2026): upgrade workflow code while existing workflow executions are in-flight
• Parent/child workflow relationships are indexed for navigating complex nested workflows
• Integrates with OpenAI Agents SDK for durable AI agent execution

Best For

• Teams that already run Postgres and want durability without a new cluster
• Background jobs, scheduled workflows, AI agent pipelines
• Lightweight durable execution in serverless and container environments

Template (TypeScript)

import { DBOS } from '@dbos-inc/dbos-sdk';

class OrderWorkflow {
  @DBOS.workflow()
  static async processOrder(orderId: string) {
    await OrderWorkflow.reserveInventory(orderId);
    await OrderWorkflow.chargePayment(orderId);
    await OrderWorkflow.dispatchShipment(orderId);
  }

  @DBOS.step()
  static async reserveInventory(orderId: string) { /* ... */ }

  @DBOS.step()
  static async chargePayment(orderId: string) { /* ... */ }

  @DBOS.step()
  static async dispatchShipment(orderId: string) { /* ... */ }
}

Inngest

Strengths

• Event-driven with a simple API
• Serverless-first (integrates with Vercel, Cloudflare, and others)
• Built-in step functions, sleep, and wait-for-event
• Great local development experience (Dev Server)

Best For

• Next.js / Vercel-based projects
• Event-driven workflows
• Background jobs

Template (TypeScript)

// Inngest function definition
const workflow = inngest.createFunction(
  { id: "[function-id]", retries: 3 },
  { event: "[trigger/event]" },
  async ({ event, step }) => {
    const result1 = await step.run("[step-1]", async () => {
      // Step 1 logic
    });

    await step.sleep("wait-period", "1h");

    const result2 = await step.run("[step-2]", async () => {
      // Step 2 logic using result1
    });

    return { result1, result2 };
  }
);

XState (v5)

Source: stately.ai/docs/actors, stately.ai/docs/setup, stately.ai/blog/2023-12-01-xstate-v5

Strengths

• Full Actor model: createActor() creates an implicit actor system where the root actor can spawn and communicate with child actors via the receptionist pattern (systemId)
• setup({ ... }) function provides type-bound action helpers, strongly typed guards, actors, delays, and context — reducing boilerplate and enabling robust type inference
• Deep (recursive) persistence: invoked/spawned actors are persisted along with their descendants
• input support: pass initial data to machines via createActor(machine, { input })
• Works in browser and Node.js; visual editor via Stately Studio

Best For

• Frontend and server-side state management
• Form wizards and UI flows
• Actor-based concurrency patterns

Template (v5 — setup + createActor)

import { setup, createActor } from 'xstate';

const machine = setup({
  types: {
    context: {} as { count: number },
    events: {} as { type: 'INCREMENT' } | { type: 'RESET' },
  },
  actions: {
    increment: ({ context }) => ({ count: context.count + 1 }),
  },
}).createMachine({
  id: '[machineName]',
  initial: '[initialState]',
  context: { count: 0 },
  states: {
    // state definitions
  },
});

const actor = createActor(machine, { input: { /* initial input */ } });
actor.subscribe(snapshot => console.log(snapshot.value));
actor.start();

Migration note: XState v4 APIs (Machine(), interpret()) are removed in v5. Use setup().createMachine() + createActor() instead.

BPMN 2.0 Engines (Camunda 8 / Zeebe)

Source: camunda.com/platform/zeebe, camunda.com — migrate from Camunda 7 to 8 (2025)

Camunda 8 (Zeebe engine)

Removed guidance: Camunda 7 (Activiti-based) is in maintenance mode. New projects should use Camunda 8. Use BPMN boundary timer + escalation events for timeouts — not BPMN error events.

AI Agent Workflow Engines

Source: LangGraph v1 adoption — fordelstudios.com (2026), Temporal + OpenAI Agents SDK — temporal.io (Aug 2025)

Non-Functional Requirements Checklist

Non-functional requirements to verify during selection: