Skip to main content

Core Engine

Camunda Features

Execute Models

The core of Camunda BPM is an execution engine for BPMN, CMMN and DMN.

It is lightweight and requires less than 3MB of disk space. It can run in any Java Virtual Machine (JVM) and comes with extended integration for different runtime containers.

You can access the engine via the REST API, or via the Java API and use existing integrations with Spring and Java EE. You can implement BPMN service tasks in Java code, or make use of the built-in REST and SOAP connectors. Besides Java, you can also apply scripts, expressions and templates for process implementation.

The Camunda Engine is lightning fast, and clustering for horizontal scalability is straightforward as the engine is stateless: multiple instances can share the same database.

This section highlights a few features of the Camunda Engine.

Download Try Online Documentation

Supported Standards

BPMN 2.0 Processes

For fully automated service orchestration and human workflow management.

CMMN 1.1 Cases

Case Management is for activities that are less structured than BPMN processes.

DMN 1.1 Decisions

Allows you to execute decision tables for business rule automation.

How you can use the engine

In your Java Application

Embed the engine as a JAR. It will be managed by your application, that can access it via the Java API.


In your Runtime Container

Install the engine in your runtime container. All your deployed applications can use it via the Java API.

Documentation Installation Guide


Run the engine where ever you like. Your applications can use it via the REST API.

REST API Reference Beginner's Tutorial

Key Concepts

Flexible Implementation

The Camunda engine offers numerous extension points for customization of process behavior by using Java Code, Expression Languages, Scripts and Templates, providing a great flexibility in process implementation.

Java Delegation Scripting

Job Executor

When ever the Camunda engine has to wait (e.g. for a user interaction or a service callback), the job executor kicks in. The Camunda Job Executor is optimized for performance and horizontal scalability.



The Camunda engine is a piece of passive Java Code which works in the Thread of the client. It can either manage transactions on its own or integrate with a platform transaction manager.


Advanced Concepts


Business processes should be tested in the same way normal application logic is tested: with unit tests. Since the Camunda engine is an embeddable Java engine, writing unit tests for business processes is as simple as writing regular unit tests.


Spring and Java EE

If you are using Spring or Java EE, you can benefit from existing Camunda integrations with those frameworks. For example, many components of Camunda are available as built-in Spring or CDI beans, and the process engine can be hooked-up to the CDI event-bus.

Spring integration CDI and Java EE integration


You may want to serve multiple tenants with a a single Camunda installation. For each tenant, certain guarantees of isolation can be made. For example, one tenant's process instances should not be able to interfere with those of another tenant.

Documentation Tutorial Whitepaper

Performance and Scalability

Persistence Strategies

Camunda does persistence as efficient as possible, applying a number of concepts.

Learn more


You can run Camunda in a Cluster in order to achieve load balancing and/or high availability.

Learn more

Runtime vs. History

Camunda separates Runtime Data from History Data, which is a powerful concept for better performance.

Learn more

All Features

You can find all core engine features in the documentation.