ekzo
BPMN 2.0 Process Engine

A BPMN engine — the execution core for business processes

A BPMN 2.0 engine with native execution and Camunda 8 compatibility. Definitions, instances, variables and history — through one REST API.

BPMN 2.0execution standard
Camunda 8compatible models
1 APImanage & diagnose
0external runtimes
Purpose

The process execution core

Workflow is the process engine of the Ekzo platform: it accepts process definitions, starts instances, maintains their state, executes automatic steps, coordinates human tasks, and exposes a single REST API to manage and diagnose all of it.

Execution is native: processes run inside the service itself, with no external runtime. Camunda Platform 8 is the compatibility reference, not the execution environment — models from Camunda Modeler / Web Modeler (Zeebe extensions, FEEL, DMN) run without rewriting.

Native engine
Processes run inside the service, no external runtime
BPMN + ETL
One core, two process types: definition → instance → variables → history
Camunda 8
Compatibility as a reference — models run as-is
Single REST API
Management and diagnostics through one interface
How it works

From definition to history

No external orchestration cluster — model definition, instance execution and the full execution history live inside a single service.

MODELS
BPMN 2.0
notation
DMN
decisions
FEEL
expressions
zeebe: ext
extensions
Ekzo Workflow — native BPMN engine
Definition → Instance → Variables → Execution state → History
VersioningPersisted stateResumes where it stopped
OUTPUT
REST API · Incidents · Execution history
Capabilities

Key capabilities

One engine and one API cover process execution end-to-end — from the model to production diagnostics.

BPMN 2.0 and ETL
One core and one API for executable BPMN and (planned) declarative ETL — no separate engines.
BPMNETLplanned
Camunda 8 compatibility
Accepts Camunda 8 / Zeebe models (zeebe: extensions, FEEL, DMN, connector model) and reproduces their execution semantics.
ZeebeFEELDMN
Modeling and diagnostics
Compatible with standard BPMN graphical modelers — a model is deployed and run straight from Camunda Modeler; incidents, execution history and instance/variable inspection.
Camunda ModelerIncidentsHistory
Zero-config, light footprint
One service and one database — no message broker and no separate workers. Low resource consumption and a simple deployment with no external orchestration cluster.
Zero-configPostgreSQLSQLite
Single management API
One REST API for definitions, instances, user tasks, forms, messages, signals, webhooks, and incidents.
RESTOpenAPI
BPMN 2.0

Full BPMN coverage

Events, tasks, gateways and subprocesses — the engine executes the full BPMN 2.0 profile with Camunda 8-compatible semantics.

Events

Start (none/message/signal/timer)✓
Intermediate catch (message/signal/timer/link)✓
Intermediate throw (none/message/signal/escalation/link)✓
Boundary — interrupting✓
Boundary — non-interruptingplanned
End (none/message/signal/error/escalation/termination)✓

Tasks

Service Task (connector)✓
Script Task (FEEL/JS)✓
Business Rule Task (DMN)✓
User Task✓
Send/Receive Task✓
Manual Task✓
External job workers (fetch-and-lock)planned

Gateways

Exclusive XOR✓
Parallel AND✓
Inclusive OR✓
Event-based✓

Subprocesses & reuse

Embedded sub-process✓
Event sub-process✓
Call Activity (versioned)✓
Multi-instance (sequential/parallel)✓
Error bubbling through scope chain✓
Connectors

Service Task connectors and events

A Service Task is dispatched to the connector registry by zeebe:taskDefinition type. Messages, signals and timers drive the process from the outside.

REST
Camunda-compatible outbound HTTP/JSON calls to external systems.
io.camunda:http-json:1
GraphQL
Outbound GraphQL queries and mutations to external APIs.
io.camunda:connector-graphql:1
Webhook
Inbound HTTP webhooks correlated into a waiting process instance.
io.camunda:webhook:1
Messages
1:1 correlation by (name, correlationKey). POST /messages, message start events.
Signals
1:N broadcast. POST /signals, signal start, cross-instance cascade.
Timers
timeDate / timeDuration, timer start, recurring ISO-8601 intervals and cron.
Management API

One REST API for everything

Definitions, instances, user tasks, messages, signals, webhooks and incidents — through a single REST API.

workflow · REST API
# Definitions
POST/processes
GET/processes
GET/processes/:id/content
# Instances
POST/processes/:id/instances
GET/process_instances
GET/process_instances/:id
POST/process_instances/:id/cancel
DELETE/process_instances/:id
# Events
POST/messages
POST/signals
# Tasks
GET/user_tasks
POST/user_tasks/:id/complete
PUT/user_tasks/:id/variables
# Incidents
GET/incidents
POST/incidents/:id/resolve
Feature map

Engine & platform capabilities

Status of core, integration and infrastructure features. BPMN notation coverage is in the “BPMN 2.0” section above.

Native execution engine✓ Done
Camunda 8 / Zeebe model format✓ Done
Versioned definitions✓ Done
Persisted state and resume✓ Done
FEEL expressions and DMN✓ Done
Input/Output mapping (ioMapping)✓ Done
REST / GraphQL / Webhook connectors✓ Done
Message and signal correlation✓ Done
Timers: catch / boundary / start / recurring✓ Done
User tasks and external forms✓ Done
Incidents: list, inspect, resolve✓ Done
Single management REST API✓ Done
Ekzo Identity integration (OAuth/OIDC, JWT)✓ Done
PostgreSQL / SQLite, background jobs in the same DB✓ Done
JSON Schema forms and input validation✓ Done
Cancel and delete instances✓ Done
Deploy and run from Camunda Modeler✓ Done
DMN, geocoding and notification helpers✓ Done
Task assignment and candidate groupsplanned
Suspend / resume instanceplanned
History in Elasticsearchplanned
ETL processes (Extract/Transform/Load)planned
Camunda 8 compatibility

Camunda models run as-is

Camunda Platform 8 is the compatibility reference, not the runtime. The engine reproduces its semantics natively.

✓
zeebe: extensions
ioMapping, taskDefinition, taskHeaders, properties
✓
FEEL
Expression language for conditions, mappings and computations
✓
DMN decisions
Decision tables and literal expressions
✓
Connector model
Camunda-style connectors (http-json, graphql, webhook)
✓
Camunda Modeler / Web Modeler
Models authored in standard editors and deployed straight from Camunda Modeler
✓
bpmn-js
Graphical diagrams and diagnostics

Models authored for Camunda 8 run without rewriting — the engine executes them natively, with no external runtime.

Comparison

Ekzo Workflow vs alternatives

The key difference is native BPMN execution + Camunda 8 compatibility without an external runtime or a heavy cluster

Ekzo WorkflowCamunda 8FlowableTemporalActiviti
BPMN 2.0 execution✓✓✓~✓
Camunda 8 / Zeebe format✓✓———
FEEL and DMN✓✓~—~
No external runtime✓—✓—✓
Unified REST API✓~~✓~
REST/GraphQL/Webhook connectors✓✓~~—
Human tasks and forms✓✓✓~✓
Light footprint (single service)✓—~—~
Self-hosted / open✓~✓✓✓
Use cases

Practical applications

Where Workflow accelerates automation and removes the dependency on an external process engine.

01
Business process automation
End-to-end scenarios: approvals, request handling, multi-step procedures — from trigger to result.
02
Integration orchestration
Coordinating external-system calls via REST/GraphQL/Webhook connectors with error handling and retries.
03
Approvals and human tasks
User tasks with forms, drafts, input checked against the form schema, and completion through a single API.
04
Scheduled execution
Start/boundary timers, recurring ISO-8601 intervals and cron — background routines without a separate scheduler.
05
Migration from Camunda
Move Camunda 8 / Zeebe models without rewriting — the engine runs them natively.
06
Part of Ekzo.Platform
Together with Relay, Registry and Identity — a full cycle of process and data automation.

Get started with Workflow

We will show how to migrate processes from Camunda without rewriting and automate scenarios on Ekzo.Platform.

Operational documentation →