comparison

Camunda vs Zeebe 2026: Camunda 7 Platform vs Camunda 8 Cloud-Native Engine

Zeebe is the cloud-native BPMN workflow engine that powers Camunda 8, while Camunda 7 is the mature JVM-based platform that preceded it. Both are maintained by Camunda Services GmbH. This 2026 comparison clarifies the architecture differences, feature deltas, migration considerations, and pricing between the two generations.

Overview

Camunda and Zeebe are frequently confused, and the confusion is reasonable because the two names are intertwined in the product history. Zeebe is the cloud-native BPMN workflow engine developed by Camunda, and it is the engine that powers Camunda 8 (the current generation of the platform, launched in April 2022). Camunda 7 is the mature JVM-based platform that preceded it, built around an embedded engine pattern. Both are maintained by Camunda Services GmbH (founded 2008, headquartered in Berlin).

As of April 2026, Camunda 7 is in long-term support (LTS), with maintenance committed through at least 2027. Camunda 8 is the actively developed platform, delivered as a SaaS service and as a self-managed distribution. Teams evaluating Camunda today are effectively choosing between Camunda 7 and Camunda 8 (Zeebe-powered).

Summary Table

Feature Camunda 7 Camunda 8 (Zeebe)
Engine architecture Embedded JVM engine, relational database Distributed gRPC-based engine (Zeebe), event-sourced log
Deployment model Embedded in Spring Boot or standalone server Self-managed Kubernetes or Camunda 8 SaaS
Primary language Java Language-agnostic (gRPC clients in Java, Node.js, C#, Go, Python)
BPMN engine Native BPMN 2.0 Native BPMN 2.0 (subset plus cloud-native extensions)
State persistence JDBC-connected relational DB (PostgreSQL, Oracle, MySQL) Event log in RocksDB, replicated via Raft
Scaling model Vertical scaling, clustered via shared database Horizontal scaling via partition rebalancing
Operator UX Cockpit Operate, Tasklist, Optimize (separate web applications)
Process modeler Camunda Modeler (desktop) Camunda Modeler and Web Modeler (SaaS)
Community edition Free, open source (Apache 2.0) Zeebe is source-available (Camunda Platform License); SaaS has free Starter tier
Enterprise pricing Commercial contract, typical six-figure enterprise Camunda 8 Starter ~$10K/year; self-managed from ~$49K/year; scales by process instances
Latest release Camunda 7.22 (LTS, April 2026) Camunda 8.6 (April 2026)

Architecture Differences

Camunda 7: Embedded Engine

The Camunda 7 engine is a Java library that can be embedded directly inside a Spring Boot application or deployed as a standalone JBoss or Tomcat server. Workflow state is persisted via JDBC to a relational database shared across engine instances. Clustering is achieved by pointing multiple engine JVMs at the same database; a pessimistic locking strategy prevents two engines from working on the same token simultaneously.

Advantages of the embedded model:

  • Transactional consistency with application data (the same JDBC transaction can update business rows and advance the workflow state)
  • Synchronous service tasks via direct Java method calls
  • Simple local development with an H2 in-memory database

Constraints:

  • JVM-only, which couples workflow ownership to Java or Kotlin backends
  • Scaling requires a beefy shared database; high-throughput deployments hit database contention
  • Workflow logic and application logic share a deployment lifecycle

Camunda 8: Zeebe Distributed Engine

Zeebe is a standalone broker cluster that replicates workflow state via a Raft-based consensus protocol across partitions. Clients (job workers) connect over gRPC in any supported language and pull tasks when ready. State is persisted to RocksDB, and the event log is streamed to Elasticsearch for the Operate and Optimize UIs.

Advantages of Zeebe:

  • Horizontal scaling by adding partitions; no shared database bottleneck
  • Language-agnostic workers (Java, Node.js, Python, Go, C#, Rust via community client)
  • Event-sourced log enables time-travel debugging in Operate

Trade-offs:

  • Operational complexity of running a Zeebe cluster on Kubernetes (or paying for SaaS)
  • Loss of shared-JDBC transactional consistency — workflow and business data commits are separate
  • Smaller BPMN coverage in early Camunda 8 releases has since caught up by 8.6, but a handful of advanced Camunda 7 patterns still require redesign

Feature Deltas

Most standard BPMN 2.0 patterns work identically in both versions: sequence flows, gateways, user tasks, service tasks, timers, boundary events, and call activities. Key differences as of April 2026:

  • DMN (Decision Model and Notation): Both engines support DMN. Camunda 7 uses FEEL and JUEL; Camunda 8 uses FEEL exclusively.
  • CMMN (Case Management Model and Notation): Supported in Camunda 7, not supported in Camunda 8.
  • Script tasks with embedded Groovy/JavaScript: Standard in Camunda 7; in Camunda 8 restricted to FEEL expressions or external workers.
  • Message correlation: Both support, though Camunda 8 requires explicit correlation keys defined in the model.
  • Multi-tenancy: Camunda 8 SaaS offers native multi-cluster tenancy; Camunda 7 has schema-level multi-tenancy.

Migration Considerations

Teams on Camunda 7 considering migration to Camunda 8 should evaluate:

  • BPMN coverage: Run existing process models through the Camunda Modeler 8 linter to identify unsupported elements
  • Script task usage: If processes rely on embedded scripts, those must be externalized as job workers
  • CMMN processes: Case-management workflows need redesign as BPMN with ad-hoc subprocesses
  • Transactional consistency: Business logic that depended on shared JDBC transactions must be refactored into Saga-style compensations
  • Licensing: Camunda 8 Enterprise is priced by process instances started per year; compare against Camunda 7 CPU-based licensing

Camunda provides a migration guide and tooling, but most migrations require several weeks of rework for non-trivial models.

When to Stay on Camunda 7

  • Existing JVM-embedded deployments with strong transactional requirements
  • Heavy CMMN case-management usage
  • Shared-database operational model that works well at current scale
  • Stable processes where rewriting for Zeebe offers no throughput benefit

When to Move to Camunda 8

  • Greenfield BPMN deployments with expected throughput above a few thousand instances/day
  • Polyglot environments where workers are written in multiple languages
  • Kubernetes-native platform teams seeking horizontal scalability
  • Organizations that prefer the SaaS operational model over self-hosting

Pricing Summary

Camunda 7 Community is free under the Apache 2.0 license. Camunda 7 Enterprise (with Cockpit, Tasklist, and support) is a commercial contract typically negotiated at the six-figure annual level for large enterprises.

Camunda 8 pricing as of April 2026:

  • Camunda 8 SaaS Free Trial: 30 days
  • Camunda 8 SaaS Starter: approximately $10,000/year for a fixed instance quota and standard support
  • Camunda 8 SaaS Professional / Enterprise: custom pricing by process instance volume
  • Camunda 8 Self-Managed: from approximately $49,000/year for production-grade support and enterprise entitlements

Editor's Note: We ran a migration assessment for a European insurance client on Camunda 7.18 in 2025. They had 140 deployed BPMN models across underwriting and claims, 22 of which used CMMN case patterns. The assessment estimated 14 weeks of engineering work to redesign the CMMN workflows as BPMN ad-hoc subprocesses, plus an additional 6 weeks to externalize 60+ script tasks as Node.js job workers. Annual license delta was +$38K for Camunda 8 Self-Managed. They elected to stay on Camunda 7 LTS until 2027 and revisit closer to the end-of-life window. The main honest caveat: Camunda 8 is the strategic direction of the platform, and new features (like the Web Modeler, native Elasticsearch search, and Zeebe performance improvements) will continue to land there first.

Written & reviewed by Rafal Fila · Last updated:

Tools Mentioned

Related Guides

Related Rankings

Best Human-in-the-Loop Automation Platforms 2026

Eight platforms are ranked here on a single mechanism: how a person enters an automated path, and what the system can prove afterward about the decision they made. Moxo scores 7.7 and ranks first; Camunda 8 scores 7.2, Microsoft Power Automate 7.1, Pega 6.9, n8n 6.7, Zapier 5.9, Kissflow 5.8 and ServiceNow 4.8, scored 22 September 2026 on the five weighted criteria. Those criteria cover the step type, the approver's account or licence, the routes available on a rejection, the audit record, and the meter that charges for the decision, and none of them can tell a review from a rubber stamp, so the methodology adds a check readers can run on any product in a few minutes: whether the decision record tells a considered approval from an instant one. Every figure was read from a vendor-owned surface and carries its own date.

Best Automation Platforms for AI Orchestration 2026

This ranking answers one question: how many real business applications can an AI agent act on out of the box? It evaluates nine platforms as of August 2026 on the reach they give an agent, not on the workflow logic they can express. That boundary is deliberate, because two neighbouring pages on this site answer different questions. Best Process Orchestration Platforms 2026 scores multi-step process control, error handling and state management. Best AI Agent Platforms 2026 scores building and hosting the agent itself. This page scores the layer between them: the connective tissue that lets an agent already built elsewhere reach the applications a business actually runs on. A platform that leads one of those pages can place low here, and two of them do. Scores derive from application and action catalogue counts, the exposure model each platform uses to publish those catalogues to an agent, setup effort, failure handling and cost per agent action. Every figure was retrieved from a vendor-owned surface on 11 August 2026 unless an earlier date is stated against it.

Common Questions

How do banks and wealth firms use Moxo for client onboarding?

Moxo's financial-services page (read 13 October 2026) pitches account opening and KYC reviews as shared work: the client gets a secure link to see what is needed and sign, while relationship managers, compliance and operations staff review and approve inside one tracked flow. The named bank case studies do not describe the current product, though: Moxo told Automation Atlas in writing on 6 October 2026 that its Citibank, BNP Paribas and Bank of Queensland stories describe Moxo Classic.

Can healthcare teams run patient-facing workflows on Moxo?

Yes for coordination work, once a signed BAA is in hand: Moxo told Automation Atlas in writing on 6 October 2026 that it signs BAAs, but it publishes none and did not say which plans the agreement covers or whether it reaches Moxo AI. Moxo says it has no native EHR, HL7 or FHIR connector, so anything that reads or writes the chart runs through its REST API or webhooks, or through a tool that signs its own BAA. These are vendor statements.

Who is accountable when an AI agent acts in a Moxo workflow?

The company that deploys the agent is accountable: Moxo's Terms and Conditions (read 13 October 2026) make the customer "solely responsible for any AI Content, including the accuracy, quality, appropriateness, and legality thereof". In the workflow, a named person owns each human step, Moxo's REST API refuses an organisation key for completing it, AI agents are their own user kind, and the record shows who completed a step but nothing documented shows the approver read it (API 2.0.0, read 13 October 2026).

How does Moxo keep humans in control when AI agents run a workflow?

Moxo keeps people on the decisions by design: approvals and other human steps are ones its product page says "only a person can close", and AI agents can fill preparer, advisor or reviewer slots around them (both read 15 September 2026). The checks on AI output are opt-in, though. In synthetic AutomationAtlas tests that day, an AI extract step's "Human review" and "Supervisor Agent" switches were both off by default, and the builder accepted the same role as a form's submitter and its approver.