Skip to content

Comparison: Camunda, Temporal & Conductor

Camunda, Temporal, Conductor, and EventConductor all orchestrate long-running business processes, but they start from very different philosophies:

  • Camunda 8 is a BPMN platform: processes are BPMN 2.0 diagrams executed by a dedicated engine (Zeebe), surrounded by a suite of tools (Modeler, Tasklist, Operate, Optimize).
  • Temporal is durable execution as code: workflows are ordinary functions in your programming language, made fault-tolerant by an event-sourced replay engine running in a dedicated cluster.
  • Conductor is a JSON-DSL orchestration platform: workflows are versioned JSON documents run by a central server cluster, with external, polyglot workers polling it for tasks. Built at Netflix, it is now community- and Orkes-governed (conductor-oss/conductor); Orkes sells a managed/enterprise build on the same core.
  • EventConductor is an embeddable, event-driven engine with a declarative DSL: workflows are flat JSON/YAML files owned by developers, executed by a Spring Boot library that scales from an in-memory unit test to a Kafka + PostgreSQL cluster.

None of the four is universally “better” — they optimize for different teams and constraints. This page compares them honestly, including where the alternatives are stronger. Facts about Camunda, Temporal, and Conductor are accurate as of September 2026 (Camunda 8.8/8.9, current Temporal server and SDKs, and current Conductor OSS / Orkes).

EventConductorCamunda 8TemporalConductor (OSS / Orkes)
Workflow definitionDeclarative JSON/YAML DSL (flat file, PR-reviewable)BPMN 2.0 XML diagrams (+ DMN for decisions)Code (workflow functions in your language)Declarative JSON DSL (versioned, developer-owned) + UI visualizer
Execution modelEvent-driven state machine (outbox pattern)Token-based BPMN engine (Zeebe)Durable execution via event-sourced replayCentral decider + queue-driven sweeper; state in an external store
Runs asLibrary embedded in your Spring Boot appDedicated cluster (Zeebe + Operate + Tasklist + Identity + Elasticsearch/OpenSearch) or SaaSDedicated cluster (server + DB, optional Elasticsearch) or Temporal CloudDedicated server cluster (+ store + Elasticsearch) or Orkes managed cloud
Minimum footprintZero dependencies (in-memory, in-process)Docker Compose / Helm with several servicesLocal dev server (single binary); production needs a clusterDocker (server + Redis + Elasticsearch); SDK harness for unit tests
Production infrastructurePostgreSQL (+ Kafka for distributed mode)Full component stack, typically on KubernetesTemporal cluster + Cassandra/PostgreSQL/MySQLRedis/Dynomite, Cassandra, or Postgres/MySQL + Elasticsearch/OpenSearch
LicenseMITSource-available (Camunda License); production self-managed requires a paid Enterprise licenseMIT (server); Temporal Cloud is the paid SaaSApache 2.0 (OSS); Orkes is the paid managed/enterprise build
Human tasks & formsBuilt-in forms engine + drag-and-drop form editorBuilt-in (Tasklist + Camunda Forms)Not built-in — model with signals/updates, build your own UIBasic Human task (OSS); full human-task orchestration + forms in Orkes
Visual designerDrag-and-drop workflow & form editors (persist back to JSON)Best-in-class BPMN Modeler (desktop & web)None (code is the source of truth)UI workflow visualizer (JSON is the source); drag-and-drop editor in Orkes
Operations UIBuilt-in management UIOperate + OptimizeTemporal Web UIBuilt-in UI (search via Elasticsearch/OpenSearch)
Retries / timeoutsDeclarative per step (retries, timeout)BPMN error/timer events + job retriesRetry policies & timeouts in code (very fine-grained)Declarative per task definition (retryCount, backoff, timeout policies)
Saga / compensationDeclarative (compensable + compensationStepId, reverse-order execution)BPMN compensation eventsCoded manually (saga pattern in workflow code)failureWorkflow — a compensating workflow on failure (not reverse-order steps)
Worker languagesJava/Spring first-class; any language via Kafka in distributed modePolyglot job workers over gRPC (Java, Node, Go, …)Go, Java, TypeScript, Python, .NET, PHP, Ruby SDKsPolyglot SDKs long-polling (Java, Python, Go, JS/TS, C#, Clojure)
AI integrationNative MCP servers in every module + bundled AI agent serviceAI Agent connector, MCP client & A2A (8.8+), API MCP serverMCP server, OpenAI Agents SDK & Google ADK integrationsIn-workflow LLM & vector tasks + A2A (OSS); AI Prompt Studio in Orkes
Maturity & communityYoung open-source projectVery mature (company founded 2008, large ecosystem)Mature (2019, from Uber’s Cadence; large community)Mature (Netflix 2016; community/Orkes-governed since 2023; large community)
Learning curveLow (a JSON schema and a worker contract)High (BPMN, DMN, component suite, operations)Medium-high (determinism rules, replay semantics, versioning)Medium (JSON DSL + task/worker model + a cluster to operate)

Camunda is diagram-first. BPMN 2.0 is an ISO standard that business analysts can read, and the Camunda Modeler is genuinely excellent. If your organization already speaks BPMN, or process diagrams are a deliverable in themselves (compliance, documentation, business/IT alignment), Camunda is the natural choice. The cost is that the XML behind the diagram is not something developers enjoy hand-editing or code-reviewing, and executable diagrams need technical attributes (job types, I/O mappings) that make them developer artifacts anyway.

Temporal is code-first to the extreme: there is no definition artifact at all. A workflow is a function, and the engine reconstructs it by replaying its recorded history — not only after a crash, but whenever the workflow is evicted from a worker’s cache or resumes after a wait, which for long-running processes is routine. This is enormously powerful — loops, conditionals, and abstractions in a real programming language with full type safety. The trade-off is that workflow code must stay deterministic (no random numbers, no wall-clock reads, no direct I/O, no iterating unordered maps in some SDKs): a violation makes the replay diverge from its history and the instance gets stuck on a non-determinism error — which, because a fast in-and-out workflow may never replay, can surface late, in production, on one long-lived or redeployed instance. It is a real cost, well-managed in practice with the SDK’s deterministic APIs and replay tests in CI, but it is discipline the definition-as-data engines do not require. Versioning running workflows likewise needs explicit patching APIs, and the workflow logic is only readable by programmers of that language.

Conductor is the closest of the three to EventConductor’s answer: the workflow is data too — a versioned JSON document, developer-owned, not a diagram and not code. The differences are of deployment and style, not philosophy. It is a platform, not a library: a central server cluster owns and drives the state while your workers poll it from outside, so unlike EventConductor it is something you run alongside your applications rather than inside them. And its control flow is explicit and structural — FORK_JOIN, SWITCH, DO_WHILE, SUB_WORKFLOW drawn as nodes — where EventConductor lets concurrency emerge from preconditions; the explicit graph reads more directly for someone who did not write it, at the cost of more ceremony in the definition.

EventConductor sits deliberately in the middle: the workflow is data (a flat JSON/YAML document), not a diagram and not code. It is expressive enough for retries, timeouts, compensation, parallel branches, sub-processes, conditional expressions, and human tasks — but it stays a single file that fits in a pull request, diffs cleanly, and can be edited either by hand or in the included drag-and-drop editor. Business logic never lives in the definition; it lives in your workers.

Change management is where these philosophies bite. Long-running processes mean there are always instances in flight when you deploy — for a booking or an onboarding that lives for weeks, versioning is not an edge case, it is part of every release. Engines that version definitions as data handle this structurally: in EventConductor, every process instance carries an immutable snapshot of the definition it started with, so redeploying a definition can never affect running instances, while new instances pick up the new version — no migration step, no code branches. Camunda likewise keeps versioned deployments (running instances stay on their version, with optional instance migration); Conductor, also definition-as-data, versions its JSON workflow definitions, so in-flight executions keep running on the version they started with. Temporal, having no definition artifact, must version code: changing logic that touches in-flight workflows requires explicit patching APIs (patched() / getVersion()) or worker versioning, the workflow code accumulates per-version branches, and a mistake surfaces as a non-deterministic replay error. Teams run this successfully at scale, but it is recurring friction that the definition-as-data engines simply do not have.

Camunda 8 is a distributed platform. Self-managed installations run Zeebe brokers and gateway, Operate, Tasklist, Identity, Connectors, and Elasticsearch or OpenSearch — realistically a Kubernetes deployment with the official Helm charts. The SaaS offering removes that burden entirely. Zeebe itself is impressively scalable (partitioned, replicated, benchmarked at very high throughput), but you are operating (or renting) a platform that is separate from your applications.

Temporal is also a dedicated cluster: the Temporal server (frontend, history, matching, worker services) plus a persistence store (Cassandra, PostgreSQL, or MySQL) and optionally Elasticsearch for search/visibility. Your application code runs in workers that long-poll the cluster over gRPC. Temporal Cloud is the managed alternative. The local dev server is a single binary, so getting started is easy — the operational weight comes later, in production.

Conductor is likewise a dedicated cluster, but with an unusually pluggable backend. A stateless Conductor server (Spring Boot) owns orchestration; durable state lives in a persistence tier you choose — Redis/Dynomite (the classic default), Cassandra, or a relational store (Postgres/MySQL) — with Elasticsearch or OpenSearch alongside for search and the UI, and optional external payload storage (S3/GCS/Blob) for large task payloads. Servers coordinate through shared dyno-queues (work is sharded across nodes) and a distributed lock (Redisson or Postgres) that keeps one server deciding a given workflow at a time, while a sweeper/reconciler re-runs the decider on a short interval so a workflow always makes progress even with no external trigger. Your workers run outside the cluster and long-poll it over REST or gRPC. Orkes packages and operates this stack as a managed cloud (or on-prem enterprise build). Like Camunda and Temporal, it is a platform to run, not a library to embed.

EventConductor inverts the model: the engine is a library inside your Spring Boot application. There is no separate orchestrator platform to operate. Three modes, selected by configuration only, cover the whole spectrum with zero changes to business code:

ModeInfrastructureTypical use
embedded + memoryNoneUnit tests, demos, prototyping
embedded + jpaPostgreSQL / MariaDB / Oracle / H2Single-node production, local dev
kafka + jpaPostgreSQL + KafkaMulti-pod distributed production

In distributed mode, orchestrator instances coordinate through Kafka partition ownership (events are keyed by process, so each process is owned by exactly one instance) and the transactional outbox pattern, and stateless workers scale horizontally as Kafka consumers. The honest trade-off: EventConductor has not been benchmarked at the extreme throughputs Zeebe and Temporal publish. If you need millions of process instances per day, the dedicated-cluster architectures have proven headroom; for the vast majority of business workloads (thousands to hundreds of thousands of instances per day), an embedded engine on PostgreSQL + Kafka is simpler to operate and more than sufficient.

For a production evaluation, the delivery and consistency semantics matter more than any feature list. This is what each engine actually guarantees:

Camunda 8 (Zeebe) persists workflow state in an internal, partitioned, Raft-replicated log — a broker crash is survived by replica failover with no data loss up to the committed log. Job execution by workers is at-least-once (a worker may receive a job again if it fails to complete it in time), so worker code should be idempotent. The engine’s internal state transitions are effectively exactly-once within a partition. This architecture is battle-tested: it is the same design that Camunda benchmarks at thousands of process instances per second.

Temporal is built around durable execution: the full event history of every workflow is persisted, and after any crash the workflow function is replayed deterministically against that history, reconstructing the running program itself — local variables, in-line waits and all — so long-running orchestration can be written as ordinary imperative code that survives process, pod, and datacenter failures. Activities are at-least-once (retried per policy), so activity code should be idempotent. It is a genuinely different programming model, and its power comes with its own discipline: workflow code must stay deterministic, and replay makes versioning already-deployed workflows a first-class operational concern.

Conductor externalizes all state into its persistence tier and keeps the servers stateless, so its guarantees are largely the guarantees of the store you choose. Cassandra gives quorum-replicated durability at high scale; Redis/Dynomite gives fast in-memory state with configurable persistence and replication; a relational backend gives ordinary ACID commits. Task execution is at-least-once — a worker that does not acknowledge within the task’s response timeout has the work redelivered, so worker code should be idempotent — and a distributed lock keeps a single server deciding each workflow while the sweeper/reconciler re-drives it and enforces timeouts, so a workflow never silently stalls. Idempotency is keyed on workflow and task ids. The honest note: the correctness floor is comparable to the others — durable state, resume after crash — but how durable is a function of the backend and how you replicate it, not one built-in guarantee, so it is a tier you must size and operate deliberately.

EventConductor builds its guarantees on two well-understood primitives — the transactional outbox pattern and Kafka partition ownership — rather than a custom replicated log:

  • Every state transition is an immutable domain event written in the same database transaction as the state change, then relayed (publish-then-mark, so delivery is at-least-once; a crashed relay re-delivers, never loses).
  • Idempotency guards absorb the resulting duplicates: duplicate ProcessCreationRequested events with the same business key create exactly one process; a duplicate task dispatch for a step already past PENDING is ignored; worker reports arriving for steps in a terminal state (e.g. after cancellation) are discarded.
  • In multi-pod deployments, events are keyed by process, so every event for a process lands on one Kafka partition and the consumer group hands that partition to exactly one orchestrator — each process has a single writer by construction, so each step is dispatched exactly once. An optimistic-locking version on the aggregates fences the brief rebalance window (and worker replies that arrive unkeyed), rejecting a stale writer instead of overwriting. (Embedded single-DB mode, where nothing partitions processes across pods, falls back to a per-process row lock — SELECT … FOR UPDATE on the process row.)
  • A timeout scheduler detects hung tasks (workers that never respond) and drives them through the same retry/error/compensation pipeline; condition expressions are fail-closed (an evaluation error means the guarded step does not run) and evaluated in a sandboxed JEXL environment that blocks reflection and system access.

These guarantees are not just claimed — they are pinned down as an explicit, public test specification (TESTING.md) covering orchestration semantics, failure handling, idempotency, durability through the real outbox, and security, run in CI on every commit. A distributed chaos suite (orchestrator crash recovery, two-pod dispatch exclusivity, worker crash redelivery) is specified in the same document.

The honest framing: all four persist workflow state durably and resume where they left off after a crash — that reliability floor is the same, and it is the property that actually matters for most workloads. What differs is the model, not a durability tier. Temporal replays history to make the workflow function itself durable (durable execution) — powerful when you want workflows-as-code, at the cost of determinism and replay-versioning constraints you may never need. Zeebe’s Raft-replicated log is proven at very high scale. EventConductor is a declarative state machine: the state is authoritative rows in PostgreSQL plus an immutable event log you can inspect with SQL, recovered by reading the current state rather than replaying code — boring, auditable technology an operations team can reason about without learning a new distributed system. Conductor is a declarative state machine too, but externalizes that state into a pluggable store (Redis, Cassandra or an RDBMS) and runs as a cluster — the same read-the-state recovery, with a backend you choose and operate. If you model a process as steps and data (the common case), you get the same state durability with far less to operate; if you specifically need workflows-as-durable-code, that is the reason Temporal exists.

Camunda 8 scales horizontally by adding Zeebe partitions and brokers. Published numbers: the smallest SaaS cluster is rated at 17 process instances/second, Camunda’s own benchmarks routinely run at 2,000 PI/s, a tuned financial-services scenario reached 6,000 PI/s with sub-second cycle time, and Intuit reported a sustained 400–500 PI/s in production. If raw orchestration throughput is the deciding criterion, Zeebe has the strongest published evidence.

Temporal is horizontally scalable until the persistence layer becomes the bottleneck; with Cassandra that ceiling is very high. Temporal states the platform supports millions of concurrent workflow executions, and organizations publicly report workloads on the order of 200M workflows/month. Temporal measures capacity in state transitions per second rather than workflows per second, since workflow cost varies enormously — worth keeping in mind when comparing numbers. EventConductor reports in that same unit and for that same reason (see Performance), which makes Temporal’s figures the directly comparable ones and Zeebe’s PI/s the ones that need a steps-per-process ratio attached before they mean anything across workloads.

Conductor scales the way the platforms do: the servers are stateless, so you add them behind a load balancer, and dyno-queues spread work across them; the real ceiling is the persistence tier, which is exactly why the backend is pluggable — Cassandra scales writes very high, Redis/Dynomite high, an RDBMS less so. Netflix ran Conductor at large scale historically, which is the track record behind it. Independent throughput numbers for the current OSS are scarce; Orkes positions its managed build at thousands of tasks per second with multi-region failover and an availability SLA, above a self-managed OSS deployment — vendor figures, so weigh them as positioning rather than a neutral benchmark, but the Cassandra-backed architecture has genuine headroom.

EventConductor scales on three axes. Workers are stateless Kafka consumers — add instances to a group and task execution scales linearly. Orchestrators scale by partition ownership: events are keyed by process, so partitions spread the work across pods and the outbox relay drains from every one. Storage is where the ceiling really sits: within a single database a transition costs a handful of fsync-bound commits, so the write ceiling is your database’s — order of tens of process instances per second of a five-transition definition on network block storage (a few hundred transitions per second), considerably higher on local NVMe, with the pods at a fraction of their CPU. For a long time that single database was also the hard limit; sharding removes it — N shared-nothing shards, each with its own database, added and removed hot, so write capacity scales with the shard count (the same shard-your-storage principle Temporal uses), opt-in and config-only with a single-database deployment unchanged. The honest framing, unchanged: EventConductor has not been benchmarked at the extreme throughputs Zeebe and Temporal publish, and while sharding’s engine paths are unit- and e2e-tested, a live multi-shard run at those rates has not been published — so for proven headroom today the dedicated clusters lead. The ceiling is now what you provision, not one node’s WAL, and you can measure whichever you run with the harness in the repo. Detail: Performance and the subsections below.

None of these engines avoids the cost of making state durable — each must commit before it can safely proceed. (Conductor maps onto the same two levers by its choice of backend: Cassandra in the replication column, an RDBMS on local disk, Redis/Dynomite a memory-first variant.) What separates them is how they pay for it, and there are only two levers:

  • Durability by replication. Zeebe considers state committed once it reaches a Raft quorum of replicas; the local disk flush is configurable precisely because it is not the primary durability mechanism. Temporal on Cassandra is similar — quorum replication plus a commitlog that is periodic by default. A datacenter round-trip is cheaper than an fsync on network storage, but you are operating a quorum cluster to get it.
  • Amortising writes. Temporal persists the entire outcome of a workflow task — every command the workflow function produced — in a single write, and tracks delivery with a per-shard ack watermark instead of marking each message individually. Five activities scheduled in parallel cost one write, not five. This is the same idea as PostgreSQL group commit, but provoked by design rather than left to load.

EventConductor uses neither. It makes one durable write per transition against the PostgreSQL WAL, and gets amortisation only incidentally, from group commit when concurrency happens to be high. That is a direct consequence of the value proposition — the engine lives inside your application, on the database you already operate — and it is what sets the ceiling described below.

Durability by replicationDurability by local disk
Amortises writesZeebe · Temporal/CassandraTemporal/PostgreSQL
Does not amortise—EventConductor

Two things follow that are easy to get wrong. First, for a like-for-like comparison: Temporal on PostgreSQL pays fsync per commit exactly as EventConductor does. Its advantage in that configuration is arithmetic — batching and sync match — not a different durability architecture. The architectural gap only opens when Temporal runs on Cassandra. Second, amortisation buys throughput, not latency: batching adds delay to the first transition in a batch, and all of them report per-transition latency in the same order of magnitude. If what matters to you is the cycle time of one business process rather than the aggregate rate, this axis may not decide anything.

  • Workers are stateless Kafka consumers — add instances to a consumer group to scale task execution linearly. The engine dispatches work and drives the state machine; it never executes business logic itself, so it does not become a bottleneck as business logic grows heavier.
  • Orchestrator instances scale horizontally in the sense that each owns the processes whose partitions it holds. Within one database, adding pods does not raise the write ceiling — they all commit against the same WAL; extra pods buy concurrency (which makes group commit more effective, a real but sublinear gain), not a higher ceiling. To raise the ceiling itself, sharding gives each shard its own database and WAL, so write capacity scales with the shard count (see below).

A transition costs a handful of database commits, and every commit costs an fsync. On network block storage doing ~350 fsync/s that puts the ceiling in the order of tens of process instances per second, with the orchestrator pods sitting at a fraction of their CPU limit; on local NVMe it is considerably higher. Storage latency, not the engine, is what a deployment should be sized against — see Reliability for the measurements.

That is not thousands per second and should not be read as such. It is, however, roughly 900,000 process instances a day at 10/s and 4M a day at 50/s. Reaching thousands per second means thousands of bookings, invoices or payments per second — a regime that exists (hyperscale event processing, high-frequency fintech) but that most business-process workloads never approach. If yours does, Zeebe and Temporal have paid the operational complexity to give you that headroom today.

That single-database ceiling is no longer architectural, though. Sharding runs the engine as N shared-nothing shards — each a full stack with its own database — so the write ceiling scales with the shard count, the same shard-your-storage principle Temporal uses. It is opt-in and config-only (a shard is the stock engine re-pointed by config; a single-database deployment is unchanged), and elastic: shards are added and removed hot, and because a process is transient the fleet rebalances by draining rather than migrating — no reshard, no data copy. And it does not cost you the single pane of glass: the CQRS process-index read model projects every shard’s status changes into one queryable index, so “list everything running”, the fleet counts, and lookups by business key still answer from one place across all N shards — sharding scales the write side without scattering the operational view. Two things keep the comparison honest: it is off by default, and while its engine paths are covered by unit and e2e tests, a live multi-shard run at thousands-per-second has not yet been published — so for proven extreme throughput today, Zeebe and Temporal still have the track record. What has changed is that the ceiling is now what you provision, not one node’s WAL.

A different property matters when load is bursty rather than sustained. Every ingress — process creation, worker tasks, domain events — rides a durable Kafka log, so a spike above the ceiling is absorbed as backlog and drained, not rejected: arrival rate is decoupled from processing rate. A Black Friday or month-end peak queues durably and clears at the engine’s steady rate — the trade is latency, not lost or refused work. It smooths spikes; it does not raise the sustained ceiling (that is what sharding is for), and Kafka’s retention bounds how large a backlog can grow. This is a deliberate contrast with the dedicated clusters, which lean the other way to protect themselves under overload — Zeebe applies backpressure and rejects commands at ingress (RESOURCE_EXHAUSTED), Temporal rate-limits per namespace — pushing back on the caller rather than buffering for it. Neither approach is strictly better: buffering favours absorbing a transient burst without touching the client, backpressure favours bounded, predictable latency under sustained overload. And the gap is one of defaults, not capability — you could front Zeebe or Temporal with your own durable queue and get the same absorption, but that is a layer you design, build and operate; in EventConductor the buffer is the ingress bus, there by construction.

EventConductor’s published baseline comes from the distributed test suite (DIST-05 in the test plan, reproducible with mvn -Pdist-e2e). It creates 500 concurrent process instances — three worker-executed steps each, i.e. 1,500 task executions — and asserts they all complete with no lost or stuck instances. The most recent run:

DIST-05 metricMeasured
Process instances500 (3 ACTION steps each → 1,500 task executions)
Wall clock (submit → all completed)5.5–6.4 s
End-to-end throughput390–455 transitions/second (78–91 process instances/s × 5 transitions: three ACTION steps between START and END)
Lost or stuck instances0

Read that as a smoke test, not as a scalability figure. It runs on laptop-class hardware (Apple M3 Max) with the pods, the broker, the database and the load generator all on the same machine, so what it mostly demonstrates is that nothing is lost or stuck under concurrency. Setting it beside Zeebe’s published thousands would be comparing a laptop to a cluster.

The number that is comparable is what the engine adds per transition — the gap between one step finishing and the next starting, which contains no worker time: 7.7 ms p50, 11.7 ms p95 at 200 transitions/second (40 instances/second of a five-transition definition). See Performance for how that is measured, the two ways it is easy to measure wrongly, and a harness that reproduces it on your own hardware.

For every deployment mode measured the same way on one machine — sequential, saga, fan-out, timers, message correlation and synchronous invocation — see Benchmarks (local). Those numbers compare EventConductor’s modes and versions with each other; they are deliberately not set against other engines’ published figures.

The axis that does scale: one engine per bounded context

Section titled “The axis that does scale: one engine per bounded context”

Because the ceiling is a property of a database rather than of the engine, the way to raise it is not to add orchestrator pods — it is to stop sharing the database. EventConductor is embedded, so its natural unit of deployment is the service: one engine in billing with its own PostgreSQL, one in booking with its own, one in fulfilment. Separate WALs, separate ceilings, and total capacity that grows linearly with the number of contexts.

For a peak inside a single context — booking alone on Black Friday — the complementary axis is sharding: it spreads one context across N shared-nothing shards, so that context’s ceiling grows with the shard count too. The two compose — bounded contexts grow capacity across domains, sharding grows it within one — and neither costs you the operational view: the CQRS process-index still answers “what is running” across every shard from one place.

This is the same reasoning that produced database-per-service, applied to orchestration. It is also why the comparison looks different from the other direction: running one Zeebe or Temporal cluster per domain is not something teams do, so a shared cluster with multi-tenancy is how those platforms partition workloads. EventConductor partitions by deployment instead. That is why multi-tenancy is absent from the feature matrix — the isolation boundary is the service, not a tenant inside a shared cluster.

  • EventConductor is MIT-licensed, free for any use, including production. Your only costs are your own infrastructure (a database you probably already run, plus Kafka if you go distributed).
  • Temporal’s server is MIT-licensed and free to self-host; you pay in operational effort or by using Temporal Cloud.
  • Camunda 8 moved to a source-available license (Camunda License 1.0) with version 8.6: self-managed is free for development and non-production use, but production self-managed requires a paid Enterprise license (a free non-commercial license exists for qualifying individuals, academia, and non-profits). Camunda 7’s community edition reached end of life in October 2025.
  • Conductor is Apache-2.0 and free to self-host — you operate the server cluster and its backing store. Orkes is the paid offering (managed cloud or on-prem enterprise), and it is where RBAC, a secrets store, mature human tasks, analytics dashboards, and the multi-region SLA live — so the OSS/paid split resembles Temporal’s, except Orkes bundles more enterprise capability into the commercial tier.

If a fully free, open-source production deployment matters to you, that narrows the field to Temporal, Conductor (both self-hosted clusters, MIT / Apache-2.0), or EventConductor (embedded, on infrastructure you already have) — with the caveat that the two clusters cost you operational effort EventConductor does not, and that Conductor’s enterprise features largely sit in the paid Orkes tier.

Failure handling: retries, timeouts, sagas

Section titled “Failure handling: retries, timeouts, sagas”

All four handle failure well — the difference is where you express it.

EventConductor — declaratively, per step in the definition:

- id: reserve-flight
type: ACTION
topic: flight-service
timeout: PT30S
retries: 2
compensable: true
compensationStepId: cancel-flight

On exhausted retries, compensation steps for previously completed compensable steps run automatically in reverse order — the saga pattern without writing saga code.

Camunda — via BPMN constructs: job retries on service tasks, timer boundary events for timeouts, error boundary events, and BPMN compensation events with compensation handlers. Complete and standard, but spread across diagram elements and their technical bindings.

Temporal — in code, with the finest-grained control of the four: per-activity retry policies (initial interval, backoff, max attempts, non-retryable error types), multiple timeout types (schedule-to-start, start-to-close, heartbeat), and sagas implemented as explicit compensation logic in the workflow function. Maximum flexibility; you write and test it yourself.

Conductor — declaratively, on the task definition: retryCount with a retryLogic (fixed, linear, or exponential backoff), timeoutSeconds / responseTimeoutSeconds with a timeoutPolicy, and rate/concurrency limits. Compensation differs from EventConductor’s reverse-order model: you attach a failureWorkflow to a workflow and Conductor starts it when the workflow fails — a separate, explicitly authored compensating flow rather than automatic reverse-order rollback of the completed steps. More flexible for bespoke recovery, less automatic for the common undo-in-reverse case.

What the diagram costs: an asynchronous, compensating saga

Section titled “What the diagram costs: an asynchronous, compensating saga”

The section above says where each engine expresses failure handling. This one measures what it costs, by modelling the same process twice.

The process is a travel booking: reserve a flight, a stay, a transfer and some excursions, confirm to the customer, and undo everything already booked if any step fails. Two constraints, both ordinary in an event-driven shop:

  • every unit of work is handed to a worker by publishing an event, and the step finishes when the worker’s event comes back — compensations included;
  • every step has a timeout and a bounded number of retries, because a step waiting for a reply that will never arrive is not a slow step, it is an invisible one.

Both definitions are downloadable and directly comparable: travel-saga.ec.yaml and travel-saga.bpmn (BPMN 2.0 with diagram interchange; it opens in Camunda Modeler or bpmn.io).

EventConductorBPMN 2.0
Definition100 lines, 11 steps771 lines, 214 elements
Per service1 step1 sub-process containing 10 nodes
Message declarationsnone — the topic plus the TaskExecutionRequested / TaskStatusChanged contract are the engine’s23
Drawing planes to maintainnone — the graph is a derived view10
Elements that say something about the business11 of 1114 of 214 (7%)

The other 200 elements are mechanics: 9 send tasks, 9 event-based gateways, 22 catch events, 9 “retries left?” gateways, 9 script tasks whose entire job is attempts + 1, 9 boundary events, and 106 sequence flows.

Standard BPMN has no first-class notion of work handed to an external worker. It can send a message and it can wait for one, so an asynchronous call becomes a send task, an event-based gateway, one catch event per possible answer, and a timer for the case where no answer arrives. Bounded retries have no declarative form at all, so they become a counter variable, a gateway and a loop back. Compensation is the one of the four where BPMN is declarative — a boundary event and a handler — and it is also the only one that does not multiply.

And because each of those is a node, they all carry the same visual weight: Reserve flight and attempts + 1 are drawn as the same box, on the same line. The notation has no altitude, so a reader cannot separate intent from plumbing, and a reviewer has to read all 214 elements to find the 14 that matter.

The trade is the one Maven and Spring Boot make

Section titled “The trade is the one Maven and Spring Boot make”

Nothing above is a defect in BPMN; it is the difference between a notation that assumes nothing and one that fixes its conventions. Maven simplified builds by deciding where sources live and what a lifecycle is; Spring Boot simplified applications by deciding how things are wired. EventConductor decides that work is dispatched asynchronously to a worker, that a failed step waits out a backoff and retries, and that a failed saga is undone in reverse order of actual completion — so none of that has to be expressed, and none of it can be expressed wrong. The plumbing is not modelled, so it cannot be mis-modelled.

The same sentence carries the cost, as it does for Maven and Spring Boot: conventions are a gift while you are inside them and a fight when you step outside. BPMN can put a deadline on a group of steps with one timer boundary event on a sub-process, cancel a whole block from the outside, or compensate only one sub-scope. EventConductor has no scopes: timeouts are per step, and compensation is process-wide. When you need those, the verbose notation is the one that can say it.

This measures standard BPMN with the messaging modelled explicitly. Accept Camunda’s job-worker protocol — a service task plus an external worker — and each service is one node again: roughly 20 nodes in a single plane, and a clean diagram. But then the asynchrony, the timeout and the retries live in vendor attributes (zeebe: / camunda:) rather than in the standard, which is the same trade EventConductor makes, minus the portability. If a Camunda deployment is a given, its diagram will be clean too; the point is that portable BPMN cannot describe asynchronous workers without drawing them.

And this is not two diagrams being compared. In EventConductor the definition is a list of steps and the graph is derived from it, so there are no coordinates to lay out, no planes to keep in sync, and nothing to lay out wrongly. That is a real reduction in what has to be maintained, but it is a declaration being compared against a diagram, not like against like.

This is where the four diverge most sharply:

  • EventConductor ships a forms engine as a first-class module: form definitions in JSON, a drag-and-drop form editor, validation, versioned storage, and dynamic rendering to any front-end. A USER_TASK step references a formId; the engine creates the form execution, pauses the process, and resumes it on submission. Task list and form UI are included.
  • Camunda also treats human tasks as first-class: BPMN user tasks, Camunda Forms with a visual form builder, and the Tasklist application. Mature and complete — human workflow has been Camunda’s bread and butter since its beginnings.
  • Temporal has no built-in human task concept. A human step is modeled as a workflow waiting on a signal or update; the task inbox, form rendering, validation, and completion UI are all yours to build. Perfectly doable — but it is application work, not engine features.
  • Conductor sits between the two: OSS ships a basic Human system task — a step that waits for external completion — but the surrounding machinery (task inbox, forms, assignment, SLA timers, escalation, delegation) is largely Orkes commercial. Self-hosted OSS gives you the wait-for-a-human primitive; the full human-workflow experience is a paid feature, where Camunda and EventConductor include it.

If your processes are human-heavy (approvals, reviews, data entry), EventConductor and Camunda give you a large head start over Temporal — and over self-hosted Conductor OSS, whose richer human tasks are an Orkes feature.

The landscape changed in 2025–2026 and all four now have an AI story — but they address different problems:

  • Camunda focuses on AI inside the process: the AI Agent connector plus BPMN ad-hoc sub-processes let an LLM-driven agent choose and invoke tools as part of a running process, with an MCP client connector (and A2A support arriving in 8.9) for external tools, plus an MCP server over its orchestration API. Powerful, and tied to the BPMN toolchain and its licensing.
  • Temporal focuses on durable AI applications: integrations with the OpenAI Agents SDK and Google ADK run LLM calls and tool executions as retryable Activities, and a Temporal MCP server lets AI assistants inspect and operate a cluster in natural language.
  • Conductor focuses on AI inside the process, like Camunda: the OSS core now ships an ai module (LLM tasks, embeddings and a vector-DB abstraction for RAG-style steps) and agentspan with agent-to-agent (A2A) support, so an LLM call or an agent step is just another task in the graph; Orkes adds an AI Prompt Management Studio (versioned, testable prompts) on top. The emphasis is putting AI into workflows, where EventConductor’s is operating the engine and your services through AI over MCP.
  • EventConductor focuses on operating the engine — and your domain — through AI, out of the box: every module (orchestrator, forms engine, and any of your own services via the McpTools interface) exposes its capabilities as native MCP servers, and the bundled ia-agent-service connects them to an LLM so operators can say “retry all failed processes from today” or “show me pending user tasks for the onboarding workflow” with zero integration code. Each server self-describes its domain through a system-context MCP prompt, so the agent’s knowledge stays current as your services evolve.

EventConductor was, to our knowledge, the first workflow engine to ship native MCP support; it remains the only one where MCP exposure of the engine and your own business services is a built-in, embeddable feature rather than a separate connector or add-on.

A detailed capability-by-capability view. ✅ built-in · 🟡 possible with extra work or limitations · ❌ not available.

CapabilityEventConductorCamunda 8TemporalConductor (OSS / Orkes)
Sequential & parallel execution (fork/join)✅ FORK/JOIN + multi-preconditions✅ gateways✅ native code✅ FORK_JOIN / FORK_JOIN_DYNAMIC / JOIN
Sub-processes✅ PROCESS step✅ call activities✅ child workflows✅ SUB_WORKFLOW
Conditional branching✅ JEXL expressions✅ gateways + FEEL✅ native code✅ SWITCH (+ Inline/Lambda)
Dynamic / data-driven flow shape🟡 expressions over a static graph🟡 multi-instance, ad-hoc sub-processes✅ unrestricted (it’s code)✅ FORK_JOIN_DYNAMIC + DO_WHILE
Declarative retries & timeouts✅ per step✅ BPMN + job retries🟡 in code (finest control)✅ per task definition
Saga compensation✅ declarative, reverse-order✅ BPMN compensation events🟡 coded manually🟡 failureWorkflow (compensating workflow)
Human tasks + forms + task UI✅ built-in module + editors✅ Tasklist + Forms❌ build your own🟡 OSS (Human task) · ✅ Orkes
Timer / delay steps (“wait 3 days”)✅ TIMER step (duration or date variable)✅ timer events✅ durable timers✅ WAIT task
Cron / scheduled process starts✅ cronExpression on the definition✅ timer start events✅ Schedules✅ scheduler module
Message correlation into running processes✅ WAIT_FOR_MESSAGE / SEND_MESSAGE steps (JEXL correlation)✅ message events✅ signals & updates✅ event handlers (SQS/Kafka/AMQP/NATS)
Query running workflow state✅ repositories / API / UI✅ Operate API✅ queries + visibility API✅ REST/gRPC + UI
Business decision tables✅ rule engine (RULE step; expression rules & decision tables in JSON/YAML)✅ DMN engine🟡 code🟡 no DMN (use SWITCH/Inline)
Definition versioning✅ versions + draft working copies✅ versioned deployments🟡 code patching APIs✅ versioned workflow defs
Per-definition concurrency limits & queueing✅ maxConcurrentExecutions + enqueue🟡 not built-in🟡 workflow-id uniqueness, worker limits✅ task rate / concurrency limits
Multi-tenancy❌✅✅ namespaces✅ Orkes (❌ OSS)
GitOps import of definitions✅ built-in Git import🟡 Web Modeler / pipelinesn/a (code deploys)🟡 metadata API / CLI
Audit trail / history per instance✅ logs + step history✅ Operate + history data✅ full event history✅ execution history + search
Engine metrics (Prometheus etc.)✅ engine counters/timers/gauges via Micrometer (reference)✅ extensive✅ extensive✅ Prometheus / metrics
Process analytics & reporting✅ built-in per-definition analytics (guide) — not a BI suite like Optimize✅ Optimize🟡 visibility/search attributes✅ Orkes dashboards (🟡 OSS)
Workflow & form visual editors✅ included, output is JSON✅ Modeler (best-in-class)❌🟡 visualizer · ✅ Orkes editor
AI agent / MCP integration✅ native, engine + your services✅ connectors (8.8+)✅ SDK integrations + MCP server✅ in-workflow LLM / A2A
Embeddable in your application✅ core design❌❌ (dev server only for tests)❌ (dedicated cluster)
Zero-infrastructure test mode✅ in-memory, in-process🟡 Testcontainers🟡 local dev server / test framework🟡 SDK test harness / in-memory

The gaps are as informative as the checkmarks: if you need multi-tenancy inside a single engine — one deployment serving isolated tenants — Camunda, Temporal, and Orkes have it and EventConductor does not. Note, though, that this follows from the architecture rather than being a missing feature: an embedded engine partitions by deployment, so the isolation boundary is the service (see one engine per bounded context). If your tenants are genuinely a runtime dimension of one shared deployment, that distinction will not help you and the platforms are the better fit. Conversely, if you want the engine inside your application, workflows as reviewable data, forms included, and MIT licensing in production, only EventConductor offers that combination.

Choose Camunda if:

  • BPMN is a requirement — analysts model processes, diagrams are compliance artifacts, or you migrate from another BPMN engine.
  • You want the most mature tooling for business/IT collaboration (Modeler, Optimize analytics) and enterprise support, and the licensing cost is acceptable.
  • Process orchestration is a platform-level, organization-wide concern with a dedicated team to run it.

Choose Temporal if:

  • Your workflows are complex code — dynamic branching, rich data structures, logic that a declarative format can’t express comfortably.
  • You need extreme scale or polyglot workflow authors (Go, TypeScript, Python, .NET teams writing their own workflows).
  • Human tasks are rare or absent, and your team is comfortable with determinism rules and workflow versioning.

Choose Conductor (OSS / Orkes) if:

  • You want declarative JSON workflows like EventConductor’s, but as a standalone, language-agnostic platform with first-class polyglot worker SDKs (Go, Python, .NET, JS) rather than an embedded Java/Spring library.
  • You want an explicit, structural control-flow graph (FORK_JOIN, SWITCH, DO_WHILE) and a pluggable persistence tier — Cassandra when you need proven high scale — and you are willing to run the cluster, or to buy Orkes to have it managed with enterprise RBAC, secrets, and human tasks.
  • Your workers are polyglot and a poll-based task model suits them.

Choose EventConductor if:

  • You live in the Java/Spring ecosystem and want orchestration as a library, not another platform to operate.
  • You want workflows as reviewable, versionable data files — with retries, timeouts, sagas, parallelism, and human tasks declared, not coded.
  • Human tasks and forms matter, and you want them (plus editors and a management UI) included.
  • You want MIT-licensed software in production and the same code running from a unit test to a Kubernetes cluster.
  • AI-driven operations via MCP is part of your vision, without building the integration yourself.

Read the Temporal trade-off as fit, not fragility. Its determinism rules, workflow versioning and replay debugging are a genuine learning curve and an ongoing discipline — but a learnable and well-tooled one (SDK guardrails, replay tests in CI, and Temporal Cloud to take the cluster off your hands), not a defect. If your process truly needs durable execution as code, that discipline is worth the investment and nothing else matches it. If your process is naturally steps and data, a declarative engine simply spares you the discipline — you skip the cost because you would be paying for power you are not going to use, not because the alternative is delicate. Choosing the simpler tool is a statement about your problem, not a verdict on the others.

It is fair to also state the reverse: EventConductor is a young project without Camunda’s ecosystem, Temporal’s proven extreme-scale deployments, or Conductor’s polyglot-platform maturity; its engine is Java/Spring only (workers can be any language via Kafka), and there is no BPMN standard behind it. Conductor in particular is the closest alternative in philosophy — declarative JSON owned by developers — so if you want that model as a standalone, polyglot platform (and are happy to run a cluster, or pay Orkes to) rather than an embedded library, it is the natural thing to weigh EventConductor against. If those are your constraints, the alternatives above are excellent tools.