Stella Ops Workflow compared with other workflow engines
This page helps you decide whether Stella Ops Workflow fits your application. It compares where each engine runs, how you define workflows, how state survives and scales, how a waiting instance wakes up, human tasks, versioning and activation, integrations, checking a workflow before it runs, shipping workflows with the service that owns them, running on your own infrastructure, and changing a workflow while instances run.
Every statement about another product cites that product’s public documentation as read on the date the Sources table gives, quoting it where the wording matters. Products change: read the cited page before you decide. Statements about Stella Ops Workflow describe the packages documented in these guides. The page describes each product’s approach as a design choice. A cell that says “not compared” means the cited documentation did not settle the question; it is not a claim that the feature is missing.
In one paragraph
Stella Ops Workflow is a set of .NET libraries: the engine runs inside your own service, keeps its state in your PostgreSQL or MongoDB database, and scales with the instances of that service. Temporal, Camunda 8 and Conductor run a separate workflow service that your code connects to. Elsa Workflows and Workflow Core are .NET libraries like Stella Ops Workflow, and Elsa can also run as a server application. Azure Durable Functions runs orchestrations written as code on the Azure Functions host, and Dapr Workflow runs its engine in the Dapr sidecar next to your application. WorkflowEngine.NET is an embedded .NET engine built around schemes; Flowable, Camunda 7, Operaton and CIB seven are embeddable Java engines for BPMN, and Apache KIE (Kogito) generates process code into Quarkus or Spring Boot applications. Restate and Cadence also run a separate server; the standalone Durable Task SDKs connect to Microsoft’s managed Durable Task Scheduler; MassTransit sagas are state machines in a .NET messaging framework. Stella Ops Workflow’s own emphasis is governance and control: versioned, immutable definitions with a fenced, audited activation, human tasks with roles and an authorization model, and a compile-time analyzer that reports most C# that cannot be expressed as a portable JSON definition.
At a glance
| Runs as | Workflows are defined as | Human tasks | |
|---|---|---|---|
| Stella Ops Workflow | Libraries inside your .NET service; state in your PostgreSQL or MongoDB | A C# builder checked at compile time, or canonical JSON | Built in: roles, assignment, deadlines; served by the HTTP API to your own front end |
| Temporal | A separate Temporal Service; your code runs in Workers [T1] | Deterministic workflow code written with a Temporal SDK [T2] | Modelled with Signals and Updates [T7] |
| Camunda 8 | A separate Zeebe cluster [C1] | BPMN and DMN models [C2] | Built-in user tasks [C4] |
| Elsa Workflows | .NET libraries in your application, or an Elsa Server [E1] | .NET code or JSON, among other ways [E2] | A User Task feature [E5] |
| Azure Durable Functions | An extension of Azure Functions; standalone Durable Task SDKs elsewhere [A1] | Orchestrator functions in code, replayed deterministically [A3] | Waiting for external events with durable timers [A5] |
| Conductor (OSS) | A separate Conductor server that workers poll [N1] | JSON definitions, with tasks run by workers [N2] | A HUMAN task type [N4] |
| Workflow Core | A .NET library embedded in your application [W1] | A fluent C# API, or JSON/YAML [W2] | User tasks through an extension package [W4] |
| Dapr Workflow | An engine in the Dapr sidecar beside your application [D1] | Deterministic code written with a Dapr SDK [D2] [D3] | Waiting for external events, with a human approval example [D4] |
| WorkflowEngine.NET | An in-process .NET library, an HTTP API, or a standalone server [O1] | Schemes, in code or XML among other ways [O2] | Commands, and approvals through a plugin [O4] |
| Flowable | Java engines embedded in a Java application, or run as a service [F1] | BPMN, CMMN and DMN [F2] | Orchestration of human and automated work [F3] |
| Camunda 7 / Operaton | A Java library inside a JVM application, with a relational database [K3] | BPMN 2.0 [K3] | Not compared |
| CIB seven | A Java library embedded in an application, or a container-managed engine; forked from Camunda 7 [K5] [K6] | BPMN 2.0, CMMN and DMN [K5] | A Tasklist application [K6] |
| Apache KIE (Kogito) | Business applications on Quarkus or Spring Boot [G1] | Processes, rules and decisions, from which code is generated [G2] | User tasks [G3] |
| Durable Task SDKs | Your code on any compute, with Microsoft’s managed Durable Task Scheduler as the backend [A7] | Orchestrations in code, replayed deterministically [A3] | Not compared |
| MassTransit sagas | Part of your .NET application, on a message broker [M1] | Saga state machines [M2] | Not compared |
| Restate | A Restate Server in front of your services, which embed the Restate SDK [R2] | Handlers in code; each step is recorded in a journal and replayed after a failure [R2] | Durable promises resolved over HTTP [R3] |
| Cadence | A Cadence cluster, with your code in workers [Q1] | Deterministic workflow code, replayed from its event history [Q1] [Q2] | Signals [Q1] |
By dimension
Deployment and operational footprint
- Stella Ops Workflow. The engine, the store adapter and the HTTP endpoints are packages in your ASP.NET Core or worker host. You run your service and its database (PostgreSQL, or a MongoDB replica set); Redis is optional. There is no workflow server to deploy. (Hosting, Persistence and signals)
- Temporal. “The Temporal Platform consists of supervising software called the Temporal Service and application code bundled as Worker Processes.” [T1] Self-hosting means “four independently scalable services - Frontend gateway, History subsystem, Matching subsystem, and Worker Service” plus a persistence database [T4].
- Camunda 8. Clients “are libraries you embed in an application … to connect to a Zeebe cluster.” [C1] The Self-Managed orchestration cluster “includes Zeebe, Tasklist, Operate, Identity”, and “You are responsible for deploying, scaling, securing, maintaining, and updating the entire Camunda stack”. [C7]
- Elsa Workflows. “Elsa Workflows is a set of open-source .NET libraries designed to enhance .NET applications with workflow capabilities.” [E1] “An Elsa Server is an ASP.NET Core web application that lets you manage workflows using a REST API and execute them.” [E1]
- Azure Durable Functions. “Durable Functions is an extension of Azure Functions that lets you build stateful workflows in a serverless environment.” On other compute, “you use the standalone Durable Task SDKs.” [A1]
- Conductor. “Conductor is open source and self-hosted: you run the server on your own infrastructure.” [N1] Its components include an API server, decider, sweeper, database, queue, index and a distributed lock that is “Required in production”. [N7]
- Workflow Core. “Workflow Core is a light weight embeddable workflow engine targeting .NET Standard.” [W1]
- Dapr Workflow. “The workflow engine runs inside of the Dapr sidecar and orchestrates workflow code deployed as part of your application.” [D1]
- WorkflowEngine.NET. “It runs as an in-process library, a HTTP API, or a standalone server with the same schemes in each.” [O1]
- Flowable. The engines run embedded in a Java application or as a service. [F1]
- Camunda 7 and Operaton. “The process engine is a Java library responsible for executing BPMN 2.0 processes” and it “uses a relational database for persistence”. [K3] Operaton is “Born from the Camunda 7 community edition”. [K4]
- CIB seven. “The process engine is a Java library responsible for executing BPMN 2.0 processes, CMMN 1.1 cases and DMN 1.3 decisions.” [K5] Its supported environments list an “Application-Embedded Process Engine” and a “Container-Managed Process Engine and CIB seven Cockpit, Tasklist, Admin”. [K6]
- Apache KIE (Kogito). “Kogito is a cloud-native business automation technology for building cloud-ready business applications.” “The primary Java frameworks that Kogito supports are Quarkus (recommended) and Spring Boot.” [G1]
- Durable Task SDKs. “Each SDK connects to the Durable Task Scheduler as its managed backend.” They “work on any compute platform—Azure Container Apps, Kubernetes, or VMs.” [A7]
- MassTransit sagas. “MassTransit integrates with dependency injection and hosted services, so consumers and workflows run as part of your application without custom bus lifecycle code.” It runs “on brokers such as RabbitMQ, Azure Service Bus, Amazon SQS, ActiveMQ, and SQL (PostgreSQL or SQL Server).” [M1]
- Restate. “The Restate Server sits in front of your services, similar to a reverse proxy or message broker.” “Your business logic lives in services: regular applications that embed the Restate SDK.” [R2]
- Cadence. “A Cadence cluster has four services: Frontend (API gateway), History (per-workflow state machine), Matching (task list routing), and Worker (your application code).” [Q1]
Definition model
- Stella Ops Workflow. A workflow is a C# class built with a fluent builder from expressions, or a canonical JSON document (
stellaops.workflow.definition/v1); the C# form compiles to the JSON form. A Roslyn analyzer fails the build for most C# that cannot be expressed as JSON; aRunstep or another C# delegate whose body breaks no rule builds with the warning WF021, and aStella.Enginehost that registers it stops when it starts. Definitions are text that you review and version like code, and diagrams are rendered from them. (Defining workflows, Canonical definitions) - Temporal. A workflow “is written with a programming language and corresponding Temporal SDK”; the code must be deterministic: “A critical aspect of developing Workflow Definitions is ensuring that they are deterministic.” [T2]
- Camunda 8. Processes are BPMN models and decisions are DMN models. [C2]
- Elsa Workflows. Among the ways to define a workflow are “Programmatically by writing .NET code” and “Declaratively using JSON”. [E2]
- Azure Durable Functions. Orchestrations are code: “orchestrator functions must be deterministic: an orchestrator function replays multiple times, and it must produce the same result each time.” [A3]
- Conductor. Workflows are defined in JSON, and their tasks run in workers. [N2]
- Workflow Core. A fluent C# API; JSON and YAML through the
WorkflowCore.DSLpackage. [W2] - Dapr Workflow. Workflows are code written with a Dapr SDK [D2]; workflow code must be deterministic [D3].
- WorkflowEngine.NET. A process is a scheme: “You can create a scheme in code or XML”. [O2]
- Flowable. The engines “fully support the BPMN, CMMN, and DMN open standards.” [F2]
- CIB seven. BPMN 2.0, CMMN 1.1 and DMN 1.3, with a modeler “for BPMN 2.0 and CMMN 1.1 diagrams as well as DMN 1.3 decision tables.” [K5]
- Apache KIE (Kogito). The build carries “code generation logic for Kogito: processes, rules, decisions, etc.” [G2]
- Durable Task SDKs. Orchestrations are code; the .NET SDK “supports type-safe orchestration and activity definitions with source generators” [A7], and “orchestrators must be deterministic: an orchestrator replays multiple times, and it must produce the same result each time.” [A3]
- MassTransit sagas. “A state machine defines the states, events, and behavior of a finite state machine.” [M2]
- Restate. “Restate tracks every step of your code execution in a journal.” [R2] SDKs exist for “TypeScript, Java, Kotlin, Python, Go, Rust, and Ruby.” [R2]
- Cadence. “The workflow code must be deterministic which means that it must produce exactly the same result if executed multiple times.” [Q2]
Durability and scaling
- Stella Ops Workflow. Each instance’s state, tasks and pending signals are rows (or documents) in your database. The engine executes the definition compiled from the workflow registered in code; it does not replay workflow code. Several hosts share one store: a host claims a due signal with a lease (
for update skip lockedon PostgreSQL), each instance change is checked against the instance’s version, and the retention job runs under a host lock. (Persistence and signals) - Temporal. Progress is kept in “an Event History, which records the state of a Workflow Execution at each step.” [T1]
- Camunda 8. “Data is divided into partitions (shards). Each partition has a number of replicas.” [C3]
- Elsa Workflows. “Elsa is designed for high performance, working across multiple nodes in a cluster for horizontal scaling.” [E1] Nodes share a distributed lock “on a shared resource such as a database, Redis, or blob storage.” [E4]
- Azure Durable Functions. “Orchestrator functions use event sourcing to ensure reliable execution.” [A3]
- Conductor. “Scale servers and workers independently”. [N3]
- Workflow Core. For several nodes “you will need to configure an external queueing mechanism and a distributed lock manager to co-ordinate the cluster.” [W3]
- Dapr Workflow. Workflows “have the same scalability characteristics as actors.” [D1]
- Restate. “If your function crashes or fails, Restate replays the journal, skipping completed steps and resuming from exactly where it left off.” [R2] The server “relies on a distributed write-ahead log to durably record data flowing through the cluster.” [R4]
- Cadence. “The Cadence server itself is stateless. All durable state is stored in the configured persistence layer (Cassandra, MySQL, or Postgres).” [Q1]
How a waiting instance wakes up
This section describes how waiting work is woken, not how fast. For a service-based engine, the rows describe how work reaches your workers.
- Stella Ops Workflow. A timer or a signal is a row (or a document) in your database. When a signal is stored, the waiting hosts are woken by PostgreSQL
LISTEN/NOTIFY, by MongoDB change streams, or by a Redis channel. With the PostgreSQL or MongoDB driver, between signals a host waits until the next stored timer falls due, at most the configured blocking wait; with the Redis driver, a due timer is picked up within that blocking wait. (Persistence and signals) - Temporal. “Workers poll for Tasks in Task Queues via synchronous RPC.” [T8]
- Camunda 8. “Job workers request jobs of a certain type on a regular interval (i.e. polling).” “With long polling, a request is kept open while no jobs are available.” With job streaming, “jobs are automatically activated and pushed downstream to workers without requiring an extra round of polling.” [C8]
- Conductor. “The worker polls the Conductor server for tasks of a specific type.” [N8]
- Flowable. “There is a thread in the async executor that periodically checks if there are new timers that should fire” [F4].
- Dapr Workflow. “For workflows, operations are pulled from the sidecar by the application using a streaming protocol.” [D1]
- Cadence. A worker is “a process that polls a task list, executes workflows and activities, and reports results back to the Cadence server.” [Q1]
- Other products. Not compared.
Human tasks
- Stella Ops Workflow. Tasks are part of the definition: roles per workflow and per task, runtime roles, assignment to a user or roles, release, completion with a payload, deadlines with a timeout branch, and a permission evaluator you can replace. The HTTP endpoints act as the authenticated caller, and your own front end presents the tasks. (Human tasks and the HTTP API)
- Temporal. “Signals are asynchronous write requests” and Updates return a result. [T7]
- Camunda 8. “A user task is used to model work that needs to be done by a human.” [C4]
- Elsa Workflows. “Use a User Task when a workflow must pause for a person to review, approve, complete, or otherwise act on work.” [E5]
- Azure Durable Functions. Orchestrations wait with
WaitForExternalEventand durable timers [A5]. - Conductor. “The Human task (
HUMAN) is used to pause the workflow and wait for an external signal.” [N4] - Workflow Core. The
WorkflowCore.Usersextension “Provides extensions for Workflow Core to enable human workflows.” [W4] - Dapr Workflow. “an approval workflow may require a human to explicitly approve an order request”; the workflow waits for an external event. [D4]
- WorkflowEngine.NET. The Approval Plugin “adds the inbox, the outbox and the approval history.” [O4]
- CIB seven. Ships a Tasklist application with its container-managed engine. [K6]
- Apache KIE (Kogito). Release 10.2 lists “WS-Human Task Lifecycle support” for user tasks. [G3]
- Restate. “Restate provides durable promises that survive crashes and restarts”; “When the approver responds, they resolve the promise through Restate’s HTTP API.” [R3]
- Cadence. Workflows “receive signals directly in workflow code”. [Q1]
Versioning and activation
- Stella Ops Workflow. A version is immutable: different content under a stored version is refused. An import stores a version inactive; a separate activation is fenced on the expected active version and hash, audited, and a return to an older version must be requested as a rollback. Instances keep the version that started them. (Governed activation and publishing)
- Temporal. Worker Versioning is “the recommended way to handle versioning”; patching is the alternative. [T2]
- Camunda 8. “running instances will continue to run on the basis of the version they started with, new instances will be created based on the latest version of that definition.” [C5]
- Elsa Workflows. “When Elsa creates a workflow definition, it starts as version 1, marked latest and not published.” [E6]
- Azure Durable Functions. “Deploying breaking changes without a mitigation strategy … can cause orchestrations to fail with nondeterministic orchestration errors.” [A6]
- Conductor. “Changes to a definition never affect executions that are already running.” [N5]
- Workflow Core. Definitions carry a version number [W2]; the behaviour of running instances was not compared.
- Dapr Workflow. With patching, “existing workflows that are in-flight when the patch is introduced will continue to use the original code path.” [D5]
- WorkflowEngine.NET. “Modify a scheme while processes are running. The engine validates and applies the change on the next call.” [O5]
Integrations
- Stella Ops Workflow. Calls to services by name over HTTP (
endpoint,http), GraphQL and RabbitMQ (a publish, or a command that waits for its correlated reply), each a separate package. Every call can name the steps to run when it fails and when it times out, and its timeout is part of the definition. A transactional outbox carries durable messaging over a transport you supply. Custom functions, permission rules, stores, signal drivers and transports plug in through public interfaces; a store, signal driver or transport can also be loaded from a plug-in folder by theStellaOps.Pluginpackage, each plug-in in its own assembly load context. (Calling services, Durable execution, Hosting) - Temporal. Work outside the workflow runs as Activities in Workers. [T2]
- Camunda 8. “Job workers request jobs of a certain type on a regular interval (i.e. polling).” [C8]
- Conductor. “Workers poll, execute, and report — run them anywhere.” [N1]
- MassTransit sagas. “Saga state machines support request/response, both as a requester and a responder.” “The Request includes three events: Completed, Faulted, and TimeoutExpired.” [M3]
- Cadence. Work outside the workflow runs in activities, and workers run “your application code”. [Q1]
- Other products. Not compared.
Checking a workflow before it runs
- Stella Ops Workflow. The analyzer reports most C# that cannot become a canonical definition as a build error at the line that causes it; a C# delegate whose body breaks no rule builds with a warning and stops a
Stella.Enginehost at start. Every workflow aStella.Enginehost (the default) accepts has a canonical JSON definition, compiled at build time or when the host or the publisher starts; a delegate form has none, and that host and the publisher refuse it at start.Stella.InProcessruns the C# specification, inlineRuncode included. The engine validates the canonical definition, you can compare it in a review, and the engine draws a diagram from it. A definition test compiles and validates a workflow without a database; a runtime test runs it against a store, with recording transports in place of your services. A change can therefore show up as a C# diff, a JSON diff and a build result, when a definition test keeps the canonical JSON beside the code, whether a person or a coding assistant made it. (Analyzer, Testing) - Durable Task SDKs. The .NET SDK “supports type-safe orchestration and activity definitions with source generators”. [A7]
- MassTransit sagas. The test harness “Provides an in-memory transport, saga repository, and message scheduler”, and it tests “saga state machines, and routing slip activities”. [M4]
- Other products. Not compared.
Shipping workflows with the service that owns them
- Stella Ops Workflow. A service can carry its own workflows: the publisher posts the definitions bundled in the service’s assemblies to the engine’s import when the service starts. The import is idempotent (the same content changes nothing, and other content under a stored version is refused), and a new version stays inactive until an administrator activates it. (Governed activation and publishing)
- Apache KIE (Kogito). Processes, rules and decisions are generated into the application’s code [G2], on Quarkus or Spring Boot [G1].
- MassTransit sagas. “[C]onsumers and workflows run as part of your application” [M1].
- Temporal. A workflow ships as “application code bundled as Worker Processes” [T1].
- Dapr Workflow. The engine “orchestrates workflow code deployed as part of your application” [D1].
- Durable Task SDKs. Orchestrations are your code: the .NET SDK “supports type-safe orchestration and activity definitions” [A7].
- Elsa Workflows. Elsa Workflows “is a set of open-source .NET libraries designed to enhance .NET applications with workflow capabilities” [E1].
- Workflow Core. Workflow Core “is a light weight embeddable workflow engine targeting .NET Standard” [W1].
- Cadence. Workflow code runs in workers, and a Worker is “your application code” [Q1].
- Restate. “Your business logic lives in services: regular applications that embed the Restate SDK” [R2].
- Other products. Not compared.
Running on your own infrastructure
- Stella Ops Workflow. Everything runs in your network: your service, your database and, if you use it, your Redis. The licence monitor reads a local file and makes no network call (Licensing).
- Temporal, Camunda 8, Conductor. Each can be self-hosted: the Temporal Service [T4], Camunda Self-Managed [C7], the Conductor server [N1].
- Azure Durable Functions. On “Virtual machines or on-premises” Microsoft points to the standalone Durable Task SDKs rather than Durable Functions. [A1]
- Elsa Workflows, Workflow Core, WorkflowEngine.NET, Flowable, Camunda 7. Libraries inside your application [E1] [W1] [O1] [F1] [K3].
Changing a workflow while instances run
- Stella Ops Workflow. A change is checked before it runs: the analyzer fails the build for most C# that cannot be a canonical definition (a C# delegate whose body breaks no rule builds with a warning and stops a
Stella.Enginehost at start), the engine validates every definition (schema, expressions, required modules), a stored version never changes, and instances keep the version that started them. The workflow is not replayed, so the engine places no determinism rule on code; the analyzer limits what a definition may contain instead (Canonical definitions, Upgrading). - Code-first engines with replay (Temporal, Azure Durable Functions, Dapr Workflow). Workflow code must be deterministic, and a change to running code is handled with versioning or patching [T2] [A6] [D5].
- Definition-based engines (Camunda 8, Conductor, Elsa). Running instances keep the definition they started with [C5] [N5] [E6].
When to choose which
- Choose Stella Ops Workflow for long-running business processes with people in them, inside .NET services you already run, when you want definitions governed like releases and no separate workflow server.
- Choose a service-based engine (Temporal, Cadence, Camunda 8, Conductor, Restate) when you want workflows coordinated by a central service that your applications connect to.
- Choose Camunda 8 when your processes and decisions are written in BPMN and DMN.
- Choose Elsa Workflows, Workflow Core or WorkflowEngine.NET when you want an embedded .NET engine and its definition model suits your processes.
- Choose Azure Durable Functions when your code runs on Azure Functions, and the Durable Task SDKs when your orchestration code runs elsewhere and Microsoft’s managed Durable Task Scheduler suits you.
- Choose Dapr Workflow when your services already run with Dapr sidecars.
- Choose Flowable, Camunda 7, Operaton or CIB seven for BPMN inside Java applications, and Apache KIE (Kogito) for processes, rules and decisions generated into Quarkus or Spring Boot applications.
- Choose MassTransit sagas when your services already exchange messages through MassTransit and a state machine per conversation fits the process.
- Choose a managed cloud service (AWS Step Functions [P1], Azure Logic Apps Standard [P2], Google Cloud Workflows [P3]) when you want your cloud provider to run the orchestration.
