Tool in production

Camunda 7

The engine for complex business processes. User tasks for humans, DMN decisions for rules, Modeler for modelling. The answer when becomes too small and SAP too big.

Project profile

Camunda 7

BPMN workflow and DMN decision engine

As of: June 2, 2026

GitHub stars

4.3k

Forks

1.7k

Open issues

License

Apache-2.0

Latest version

v7.24.0

Language

Java

First release

January 3, 2013

Last commit

November 4, 2025

→ GitHub repository → Official website → Documentation

Third-party source · Wikidata (CC0)

Wikidata profile

Camunda

Q15790886

License

Apache License

→ Wikidata entry

What is Camunda 7?

7 is a engine and DMN decision engine in Java, established since 2013. Business processes are modelled as diagrams — start, user tasks for humans, automatic service tasks, decisions, parallel and sequential paths, escalations, sub-processes — and executed by the engine. Plus: a cockpit for observation, a tasklist as user inbox, an admin webapp.

Important for clarity: 7 Community Edition is licensed under Apache-2.0 — real OSI open source. 8 (the company's current main product) has a Source Available license with a commercial enterprise tier and is cloud-first. For SMBs with a self-hosting requirement and manageable processes, 7 remains the right choice.

Why a mid-sized industrial firm uses Camunda

At a special machine builder with complex engineering workflows, is not enough. A typical customer order runs through 8–15 stations over several weeks — construction, structural review, materials, purchasing, CFO approval. Several people are involved, some steps run in parallel, others have escalation paths. That is classic territory.

makes such processes explicit: the diagram is documentation and executable program at the same time. Each request has a clear status (which station, who is responsible, how long has it been pending). Escalation triggers on delay. The cockpit shows leadership the operational view. An audit trail is created automatically — important for ISO 9001 and occasional subsidy proof.

Client case study

Elmasco GmbH

Mid-sized manufacturer of special components for electrical machines, 60 staff — leadership, 12 designers, 8 structural engineers, 6 buyers, workshop with 28 people. Engineering approval runs around 80 times per month. 22 months ago migrated from email threads + Excel list to 7 . Today: every order has a clear status, no more 'who was responsible?' discussions, ISO 9001 audit trail is created automatically.

BPMN 2.0 standard for process modelling

Processes should be modelled in a standardised format () — so that external consultants, ISO auditors and designers without coding skills can read them. Visio-style pictures are not enough: the model must be documentation and executable program at the same time.

User tasks with forms

Designers, structural engineers, buyers, CFO — all see their open tasks in an inbox (Tasklist) with forms in which they document their decision. No more mail attachments, no more 'can you send that again?' threads.

DMN decisions automated

Rules like 'from €50,000 a CFO approval is required' or 'for part type X always a structural review' are modelled as DMN decision tables. The designer does not have to remember rules — the engine decides automatically.

Parallel paths for simultaneous reviews

Structural review and material availability check can run in parallel. A parallel gateway opens both paths, the next step (CFO approval) waits for both. Sequential would be 30 % slower.

Escalation on delays

If a designer leaves a task longer than 3 days: escalation to the head of construction via mail and Tasklist hint. Leadership sees in the cockpit where the bottlenecks are.

Audit trail for ISO 9001

Who made which decision when? Which form fields were filled? Which path did the engine pick for which decision? All in the process history, exportable as PDF for ISO 9001 and audits.

What the company actually does with it

Eight productive usage patterns from 22 months of practice at Elmasco. Each pattern replaces either an email chain, an Excel list or an 'I'll just ask' communication.

BPMN diagram in the Modeler

The head of engineering and an external consultant model the process in Modeler (standalone app). Designers see the diagram and understand the flow in 5 minutes — a visual standard, no program code. Versioning in Git.

Tasklist as user inbox

Every designer, structural engineer, buyer opens Tasklist in the morning (browser app): personal tasks, group tasks, due dates. Clicking a task opens the form, document the decision, done. No more email for steps.

DMN decisions automatic

Decision 'cfo-required' is modelled as a table: investment level, part type, customer category → path with/without CFO. The engine evaluates this per process automatically. On rule change: update the DMN file, deploy — without a programmer.

Parallel paths construction + materials

After the construction check a parallel gateway opens two paths: structural engineer reviews statics, in parallel materials checks availability. Both finish, then the process joins back. Throughput time per order reduced from 12 to 8 days.

Escalation on 3-day idle

Timer boundary event on every user task: after 3 days without movement → escalation mail to the supervisor + cockpit highlight. Bottleneck designer becomes visible, leadership can re-assign concretely.

Cockpit for leadership: all processes

The CEO opens the cockpit: 47 running engineering processes, 3 escalated, average throughput 8.2 days. Click on a process: current position in the diagram, involved people, history. Daily glance: 2 minutes.

Audit log automatic

stores every action: task started, form filled, decision made, escalation triggered, process completed. An ISO 9001 auditor can export a PDF per order with the full processing history. Audit time reduced by 80 %.

Integration with ERP via REST API

On order approval, a service task sends a REST call to the internal ERP (SAP B1) — the order is created automatically, the customer is notified. No double entry, no inconsistencies between system and ERP.

Core capabilities of Camunda 7

What 7 delivers as a platform — and which of these capabilities really carry the Elmasco setup.

BPMN 2.0 engine standard-compliant

is an ISO standard for business process modelling. implements it fully — start/end events, tasks (user, service, script, business rule), gateways (parallel, exclusive, event-based), sub-processes, escalations. The modelled diagram is documentation and program at the same time.

DMN decision engine

DMN (Decision Model and Notation) as a complementary standard for business rules. Decision tables with inputs and outputs, FEEL expressions, hit policies. Rule changes without programmer involvement — the business side changes the table, the engine evaluates.

Camunda Modeler (standalone app)

Desktop application (Windows/Mac/Linux) for modelling and DMN diagrams. Drag-and-drop, validation, element templates. Diagrams as XML versionable in Git, reviewable in pull requests.

Tasklist webapp

Browser app for end users: personal and group-related tasks, filters, sorting by due date, search, forms for processing. Connects engine and staff without those needing to know engine details.

Cockpit webapp (operations)

Browser app for owners and leadership: all running processes, filter views, escalations, statistics (throughput time, bottlenecks), the ability to intervene (change variable, move task). A live view into operations.

REST API for integration

Full REST for everything: start processes, read/close tasks, read/set variables, evaluate decisions. , ERP systems, custom frontend apps talk directly to — engine as a central hub.

Honest alternatives

If Camunda 7 is not a fit — what else?

Three alternatives with different profiles. 7 is the established choice for — the competition has its own focuses.

Current Camunda generation

Camunda 8 (Zeebe)

Camunda Services GmbH

+ Modern cloud-first approach
+ Higher scaling possible
− Source Available license (not OSI open source)
− Enterprise edition almost mandatory

Open-source alternative

Flowable

Flowable AG, Apache-2.0

+ Apache-2.0, real open source
+ Derived from Activiti, similar API
− Smaller community than Camunda
− Cockpit less mature

Simple trigger-action

n8n

n8n GmbH, fair-code

+ Very easy entry
+ 400+ pre-built integrations
− No BPMN standard, no user tasks
− Not built for complex business processes

Rule of thumb: anyone wanting self-hosting, classic and Apache-2.0 as a license is best placed on 7. 8 pays off for cloud-first setups with enterprise licence budget. Flowable is a very similar self-hosting alternative (fork roots). For simple trigger-action workflows: — a different class of tool.

Pricing

Apache-2.0. Self-hosted. No per-user licence.

License

Apache-2.0 for Camunda 7 Community Edition. Fully open source without obligations. Alongside there is Camunda 7 Enterprise Edition (commercial subscription with support) and Camunda 8 (Source Available). For SMB self-hosting Community Edition is fully sufficient.

Running costs

Two containers (Camunda Run + PostgreSQL) on an existing Docker host. RAM footprint around 1–2 GB (Java VM). No licence cost, no per-user fee, no cloud component.

Effort

Installation: 1 day (Compose, authentication, initial config). BPMN modelling of an engineering workflow including decision table and Tasklist forms: 3–5 consulting days. Training of the business side (Modeler usage, BPMN basics): 1 day per modeller.

Important: 7 Community Edition is supported with updates until October 2027 according to the official (paid Enterprise subscription beyond that). Until then: stable, mature solution. If planning beyond 2027: Flowable as a very similar Apache-2.0 alternative or calculate migration to 8 ahead of time.

Example BPMN process as XML

<bpmn:process id="engineering-approval" isExecutable="true">

  <bpmn:startEvent id="new-request" name="New construction request" />

  <bpmn:userTask id="check-construction"
                 name="Check construction"
                 camunda:formKey="embedded:app:forms/check.html">
    <bpmn:extensionElements>
      <camunda:assignee>${designer}</camunda:assignee>
      <camunda:dueDate>P3D</camunda:dueDate>
    </bpmn:extensionElements>
  </bpmn:userTask>

  <bpmn:businessRuleTask id="check-cfo-required"
                         name="CFO approval needed?"
                         camunda:decisionRef="cfo-decision" />

  <bpmn:parallelGateway id="split-checks" />

  <bpmn:userTask id="check-statics" name="Structural review" />
  <bpmn:userTask id="check-materials" name="Material availability check" />

  <bpmn:parallelGateway id="join-checks" />

  <bpmn:userTask id="cfo-approval" name="CFO approval">
    <bpmn:extensionElements>
      <camunda:candidateGroups>cfo,exec</camunda:candidateGroups>
    </bpmn:extensionElements>
  </bpmn:userTask>

  <bpmn:endEvent id="approved" name="Order approved" />

</bpmn:process>

Excerpt from an engineering approval workflow: user task 'check construction' with form, decision 'CFO approval needed?', then parallel paths. Source: own practice, BPMN 2.0 standard.

Camunda 7 self-hosted Compose setup

services:
  camunda:
    image: camunda/camunda-bpm-platform:run-7.24.0
    container_name: camunda
    restart: unless-stopped
    depends_on: [camunda-db]
    ports: ["8080:8080"]
    environment:
      - DB_DRIVER=org.postgresql.Driver
      - DB_URL=jdbc:postgresql://camunda-db:5432/camunda
      - DB_USERNAME=camunda
      - DB_PASSWORD=${DB_PASS}
      - TZ=Europe/Berlin
      - JAVA_OPTS=-Xmx1024m
    networks: [frontend, camunda-net]

  camunda-db:
    image: postgres:16
    container_name: camunda-db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=camunda
      - POSTGRES_USER=camunda
      - POSTGRES_PASSWORD=${DB_PASS}
    volumes:
      - ./camunda-db:/var/lib/postgresql/data
    networks: [camunda-net]

networks:
  frontend:
    external: true
  camunda-net:

Two containers: Camunda 7 Run (engine + cockpit + tasklist + admin) and a PostgreSQL for process history. Apache-2.0 real open source. Source: docs.camunda.org, Apache-2.0.

Camunda in the stack — what hangs around it?

is the engine for complex processes. For simple trigger-action workflows fits better. Platform is , visualisation via :

→ n8n (trigger-action workflows)→ Docker (container platform)→ Grafana (visualise process metrics)

Ready for the next step?

Free intro call, no strings attached. In 30 minutes you'll know whether and how AI can help your business.

Book a call Check eligibility