Skip to content

EventConductor

Orchestrate business processes without BPMN complexity or SaaS lock-in. Built for distributed Java/Spring environments — with native AI integration via MCP.

The video above is chapter 1 of a series of short chapters, one aspect at a time — every screen is the real product running. Each guide page embeds its chapter. Full playlist.

#ChapterWhere
1EventConductor in 3 minutesthis page (above)
2Your first processWorkshop · module 1
3Definitions: YAML, graph and IDEIDE plugins
4When a room can’t be booked: the guest decidesRetries, timeouts & compensation
5Calling the outside worldHTTP calls
6Branches, loops and sub-processesLoops & multi-instance
7People in the loopUser tasks
8Time and messagesScheduling & deadlines
9Events in, events outDomain event triggers
10AI in the processLLM calls
11Operating running processesOperating running processes
12Testing workflowsTesting workflows
13From laptop to clusterDeployment modes
14Secure and observable by defaultSecure by default

A business process starts as a few calls in a row — and then production adds the rest: undoing what succeeded when a later step fails, retries that must not book twice, a pod that dies halfway, people who answer two days later, code that changes while runs are in flight, and someone asking “where is booking 123?”. Written by hand, that is most of the code, and almost none of it is about your business.

Written by hand

Book each roomGet approvalConfirm to the customer
Compensation in reverse orderRetries + backoffTimeoutsIdempotency keysProgress tableStuck-run sweeperTransactional outboxLocks / one owner per runLate replies to cancelled workParallel fan-out + joinTimers that survive restartsTask inbox + escalationVersioning in-flight runsAudit trailSearch + admin screensRetry from step / bulk repair

All of it is yours to write, test, review and fix — in every service.

With EventConductor

Book each roomGet approvalConfirm to the customer
Built into the engineCompensation in reverse orderRetries + backoffTimeoutsIdempotency keysProgress tableStuck-run sweeperTransactional outboxLocks / one owner per runLate replies to cancelled workParallel fan-out + joinTimers that survive restartsTask inbox + escalationVersioning in-flight runsAudit trailSearch + admin screensRetry from step / bulk repair

You write the tip. The rest is declared — or simply there.

The code that never fails is the code you don't write.

It scales — in capacity and in change

From one JVM to a cluster with the same definition; millions of waiting processes cost storage, not threads. And adding a step, a branch or a whole new process stays as easy on day 500 as on day one.

You write less code

The process is a short, reviewable declaration. What remains in code is the business work inside each step — not state tables, sweepers, outboxes and locks.

The hard parts come for free

Retries, timeouts, sagas and compensation, parallel fan-out, timers, human tasks, crash recovery and versioning — declared in one line, solved once for every process.

It saves time — at every stage

Not just the first version: each change is one validated block, a definition change ships by merging to Git — no service redeploy — and tests run in memory with simulated time.

It can be operated

Every run is a live graph you can search, inspect, retry from a step, migrate or repair in bulk — audited, and from day one rather than after the first incident.

One screen per run

Its graph, steps, variables, errors and history, together — instead of correlating logs across services to rebuild what happened.

And when hand-written code is the better choice, we say that too: Why a process engine?

Distributed by design

Multiple orchestrator instances coordinate safely: events are keyed by process onto Kafka partitions, so each process has a single owner, and state is reconciled through the transactional outbox pattern. Scale from a single JVM to a multi-pod Kubernetes cluster without changing a line of business code.

Event-driven, not polling

Every state transition is triggered by a domain event — stored in the outbox table and relayed to the appropriate handler. No polling loops that grow with your data.

Developer-first DSL

Workflow definitions are JSON files — human-readable, version-controlled, reviewable in a PR. Retries, timeouts, compensation (saga), parallel execution, sub-processes, conditional branching (JEXL), and human tasks in a single flat file.

Three deployment modes

Run fully in-process for tests, single-node with PostgreSQL, or fully distributed with Kafka + PostgreSQL — no code changes required.

Built-in forms engine

User-task steps pause the workflow until a human submits a form. Forms are defined in JSON, stored in version control, and served dynamically to any front-end.

Native AI via MCP

The first workflow engine with native Model Context Protocol (MCP) integration. Any MCP-compatible AI client — Claude Desktop, a chatbot, an internal copilot — can operate the engine in natural language.