If you have used Camunda or Temporal, you know what a process engine gives you: sagas, human tasks, timers, an operations console, versioned processes. EventConductor gives you the same, MIT-licensed, as a library inside your Spring Boot app instead of a platform to run beside it — and it fixes a few things we always missed.
A three-step process is mostly plumbing
Take a hotel booking. On a whiteboard it is three steps: a manager approves it, each room is booked at the hotel, the guest is told.
In production you also need:
- Undo what was booked, but only if the guest decides to cancel when one room turns out to be sold out.
- Retry without booking twice when the hotel's API times out.
- Survive a restart halfway, with two rooms booked and one pending.
- Wait days for a person, with reminders and an escalation.
- Change the process while bookings are still running.
- Answer "where is booking 123?" without reading logs.
Written by hand, that is most of the code, and almost none of it is about hotels. It is also the part that breaks: state in three tables, retries in two places, a compensation nobody tested.
Compared with Camunda and Temporal
EventConductor covers the same ground as Camunda 8 and Temporal — the comparison is on purpose. The differences are in how you run it, what you pay, and what the process is made of.
| Camunda 8 | Temporal | EventConductor | |
|---|---|---|---|
| License | Source-available (Camunda License); self-managed production needs a paid Enterprise license | MIT server; Temporal Cloud is the paid SaaS | MIT, production included |
| Runs as | A platform: Zeebe, Operate, Tasklist, Identity, Elasticsearch/OpenSearch — typically Kubernetes, or SaaS | A cluster: Temporal server + Cassandra/PostgreSQL/MySQL (+ optional Elasticsearch), or Temporal Cloud | A library in your Spring Boot app; in-memory, PostgreSQL or Kafka by configuration |
| The process is | BPMN 2.0 XML, edited in a modeler | Code: a workflow function that must stay deterministic for replay | A flat YAML file reviewed in a pull request, also drawn and edited as a graph |
| Changing running processes | Versioned deployments, optional instance migration | Patching APIs or worker versioning in code; mistakes surface as non-determinism errors | Each instance keeps a snapshot of its definition; explicit migration with a dry run |
| Workers | Job workers over gRPC, many languages | SDKs in Go, Java, TypeScript, Python, .NET and more | Spring beans in the same app; any language over Kafka in distributed mode |
| Human tasks and operations | Tasklist, Forms, Operate, Optimize | Not built in: signals/updates and your own UI; Web UI for operations | Built-in forms engine, task inbox and operations console |
| Sagas | BPMN compensation events | Coded by hand in the workflow | Declarative compensation, undone newest first, on failure or on a business decision |
Facts about Camunda and Temporal are from our comparison page, as of Camunda 8.8/8.9 and current Temporal server and SDKs.
What we improved
- The process is a file, not a diagram's XML. A definition is short YAML that diffs cleanly and fits in a pull request. The console and the VS Code and IntelliJ plugins draw it as a graph and edit it in place, without rewriting the file.
- No platform to operate. The engine is a dependency. Start embedded with no infrastructure, move to your PostgreSQL, then to Kafka for several pods — the same definitions, no code changes.
- Versioning without migrations by default. Every running process keeps an immutable snapshot of the definition it started with. Deploying a new version never touches in-flight processes; migrating them is an explicit, audited operation with a dry run.
-
Compensation as a decision. Undo can follow a failure, or a business decision: an
ENDwithcompensate: trueundoes what was done because the customer cancelled. - Testing built in. A test kit with time travel and scenarios as data, workflow coverage, and a Maven goal that fails the build on uncovered branches or unsafe migrations.
-
AI-ready.
LLM_CALLwith structured output, anAGENTstep, and an opt-in MCP server so assistants can inspect and operate processes.
The hotel booking, declared
This is an excerpt of the real definition from the workshop. Each room is booked with an HTTP call to the hotel, with retries, a timeout and an idempotency key, so a retry never books twice:
- id: rooms
type: HTTP_CALL
name: Book every room at the hotel
compensable: true
compensationStepId: cancel-room # how to undo a room
retries: 3
timeout: PT15S
forEach:
items: rooms
as: room
label: "'Room ' + room.number"
onIterationFailure: continue # a refused room stops nothing
http:
connection: hotel
method: POST
path: /bookings
headers:
Idempotency-Key: "${businessKey}-${room.number}"
When a room is sold out, the booked rooms stay booked. The process fetches alternatives, asks the guest and waits for the answer. It never cancels on its own:
- id: wait-for-guest
type: WAIT_FOR_MESSAGE
messageName: guest-answer # accept | keep | cancel
correlationExpression: businessKey
timeout: P1D
onTimeoutStepId: remind-guest # no answer: remind, then the front desk
- id: cancelled-by-guest
type: END
compensate: true # undo what was booked, because the guest decided
preconditions:
- stepId: guest-decision
expression: "answer == 'cancel'"
The work behind a step is a Spring bean, and nothing in it knows about retries or rollbacks:
@Bean
TaskRegistration<NotifyGuestInput, NotifyGuestOutput> notifyGuest() {
return new TaskRegistration<>("notify-guest", 1, "hotel",
NotifyGuestInput.class, NotifyGuestOutput.class,
(input, context) -> {
log.info("Told {} their booking is confirmed", input.guest());
return new NotifyGuestOutput(Instant.now().toString());
});
}
Compensation is the mechanism; who decides to trigger it is your business rule. Here it is the guest, or the front desk after two days without an answer. For steps that really are one technical unit, automatic all-or-nothing compensation (onIterationFailure: compensateAll) is one line away.
In your IDE: VS Code and IntelliJ plugins
The definition is a text file, but you rarely have to read it as text. The plugins for VS Code and IntelliJ open any *.ec.yaml file as an interactive graph — the same component the console uses.
- Edit visually or as text. Drag steps from a palette, Shift+drag to connect them, set retries, timeouts or the failure policy in a side panel. The YAML beside it updates live, and only the lines you changed: your comments and formatting stay.
-
Validation as you type. The JSON schema gives completion and errors in the text view;
mvn eventconductor:validatecatches dangling references and orphaned compensations in the build. - Run it from the editor. In VS Code, Run Workflow starts a draft run of the open definition.
A definition in VS Code: the step palette, a CHOICE on the group size, a FORK into three branches and a forEach over rooms.
Both plugins are free, published on the VS Code Marketplace and the JetBrains Marketplace.
What it looks like
Every picture below is the real console, from the workshop and the demo app.
A forEach expanded into one lane per room. Room 900 was refused, 101 and 102 are kept, and the process moves on to ask the guest.
The same booking after the guest answered cancel: Cancel the room ran for the two booked rooms (2/2), and the 48-hour timeout route to the front desk is drawn as a timeout.
Operating: the process list, searchable by business key, with retry, cancel and batch operations.
What you get
Each area below has a short video chapter and a docs page.
| Area | What the engine does for you |
|---|---|
| Sagas and compensation | Compensable steps, undo newest first, compensateAll for technical units, compensate: true on an END for business decisions, one winner per XOR join |
| Calling other systems |
HTTP_CALL with named connections, auth, idempotency keys, output mapping and secrets kept out of definitions |
| Branches and loops |
CHOICE, FORK/JOIN, forEach over items with per-item labels, loops, child processes |
| People |
USER_TASK with forms, candidate groups, escalation and timeouts; a task inbox |
| Time and messages | Timers and deadlines computed from process data, WAIT_FOR_MESSAGE correlated by business key, schedules |
| Events | Triggers that start processes from domain events, webhooks, PUBLISH_EVENT, synchronous request/reply |
| AI steps |
LLM_CALL with a response schema and structured output; an AGENT step; an MCP server (opt-in) |
| Operations | Console to search, retry, pause, complete a step by hand, run batch operations and migrate running processes between versions, with an audit trail |
| Testing | A test kit with time travel, scenarios as data, workflow coverage, and mvn verify that fails the build on gaps or unsafe migrations |
| Deployment | Embedded (memory or JPA) or distributed over Kafka; standalone apps, Docker images, Helm chart; definitions imported from Git |
| Security and observability | Anonymous access refused by default, secrets only from configuration, encrypted sensitive variables, Prometheus metrics, OpenTelemetry tracing (opt-in) |
When to choose what
EventConductor fits when a business process outlives a single request — minutes or days, people in the loop, calls that fail, work to undo — and you want the engine inside your Spring app rather than a platform beside it.
Camunda or Temporal are still the better choice in some cases:
- Camunda, when BPMN diagrams are a deliverable in themselves (business analysts, compliance), or you need its very high, published throughput.
- Temporal, when you want workflows as code in several languages, and your team is ready for its determinism and replay rules.
- Neither, nor EventConductor, for a single synchronous request with no waiting, or for pure data pipelines — a plain service or a stream processor is simpler.
EventConductor is younger than both and has not been benchmarked at their published extremes. For most business workloads, an embedded engine on PostgreSQL and Kafka is simpler to run and enough.
Get started
Add the engine to a Spring Boot app:
<dependency>
<groupId>io.mateu.workflow</groupId>
<artifactId>workflow-engine</artifactId>
<version>2.42.1</version>
</dependency>
For HTTP_CALL, LLM_CALL and PUBLISH_EVENT steps in the same app, add builtin-workers too (same group and version, <type>pom</type>), and workflow-test for the test kit. Then put a definition in src/main/resources/workflows/, register a worker bean, and run the app. The console shows the process as it runs.
- Watch: EventConductor in N minutes, 14 short chapters starting with EventConductor in 3 minutes.
- Learn by doing: the hands-on workshop builds the hotel booking end to end, then tests it and puts it in CI.
- Read: the docs at eventconductor.mateu.io.
- Code: github.com/miguelperezcolom/eventconductor. Open source, MIT. Latest release is v2.42.1.




Top comments (0)