DEV Community

Miguel Pérez Colom
Miguel Pérez Colom

Posted on Originally published at Medium AI-assisted

EventConductor: an open-source alternative to Camunda and Temporal, inside your Spring app

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 END with compensate: true undoes 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_CALL with structured output, an AGENT step, 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}"
Enter fullscreen mode Exit fullscreen mode

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'"
Enter fullscreen mode Exit fullscreen mode

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());
            });
}
Enter fullscreen mode Exit fullscreen mode

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:validate catches 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 open in VS Code: the palette of step types, the process graph with a CHOICE, a FORK and a forEach over rooms

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.

Book every room, expanded into one lane per room: rooms 101 and 102 booked, room 900 refused

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 hotel booking after the guest answered cancel: the booked rooms were undone

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.

The process list in the console

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>
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)