ECA: The Next Chapter

New Modeler, In-Context Customization, Test & Replay

DrupalCon North America 2026
go.lakedrops.com/eca-chicago-2026

Jürgen Haas

24. March 2026

About myself

Member on drupal.org for almost 19 years
Maintainer of ~100 modules

Find me online:
go.lakedrops.com/jurgenhaas

Creator and maintainer

Core Subsystem Maintainer
Admin Theme

Co-founder and Managing Director

Agenda

We listened: Pain Points & Process
The Architecture: Modeler API
For Everyone: In-Context Customization
For Technical Users: The New Modeler
For Developers: Extensibility
How it got built: Numbers, Quality & Release
Q&A

go.lakedrops.com/eca-chicago-2026

We Listened

16,000+ active installs

ECA is the most powerful automation engine in any CMS.

But let’s be honest with each other.

Blank canvas shock
Steep learning curve
Token confusion
UI perceived as not modern
Too many modules
Component discovery doesn’t scale

How we went about it

We didn’t just guess what was wrong.

Collected feedback from the community
Analysed support requests and issue queues
Ran focused UX reviews

Two UX experts were instrumental in shaping the new experience:

Emma Horrell
drupal.org/u/emma-horrell

Mark Dodgson
drupal.org/u/mark-dodgson

The good news

ECA hasn’t changed at all.

Zero risk to update. Your existing models keep working.

The secret: a new abstraction layer made all of this possible.

The Architecture

Modeler API

Three layers, three audiences

Non-technical users

In-place customization, to come to all places in Drupal.

Pick a template. Configure. Done.

Technical users

Full visual Modeler.

Build, test, debug.

Developers

Plugin API.

Extend everything.

For Everyone

In-Context Customization

No admin screens. No workflow editor.

It just works – right here, on the page you’re already looking at.

You don’t even need to know what ECA is.

For Technical Users

The New Modeler

Building a workflow

Structured YAML editing

This is a killer feature. Some configuration fields require structured data as YAML.

Let’s look into the example of building tools. They can be used by AI Agents, MCP, and others.

The downside: you have to provide the input arguments in a specific form so that we can upcast the data before calling the tool.

Most users won’t ever do that, and it’s error prone.

Now: the config schema defines the structure, and the modeler turns that into a frontend widget. Strings become text inputs. Booleans become checkboxes. Lists get add/remove controls. Nested mappings become fieldsets.

You can toggle between the structured editor and raw YAML at any time. Changes sync both ways.

And in YAML mode, you get real-time schema validation. Type mismatches, missing required fields, unexpected properties – all flagged immediately.

This makes complex configuration accessible to people who would never write YAML by hand.

Test, Replay, Debug

Token handling

Before: Token syntax, scopes, availability – confusing.

Now:

See real token values during replay
Drag tokens into config fields
Styled pills: [node:title]
Edit, move, delete inline
Global tokens always visible

More highlights

Editing

Flow filtering
Search & find
Annotations
Copy / paste
Undo / redo
Auto layout

Export

Drupal Recipe
Archive (.tar.gz)
JSON (standalone viewer)
SVG image

Integration

Context support
Dependency support
Permissions (granular)
Standalone viewer
Multiple modelers (lossless)

In-Context meets the Modeler

Remember the lightning bolt?

Technical users can go further: start the Modeler directly from context.

The current form ID and field name are passed as context variables
When adding events or actions that use those parameters, the Modeler fills them automatically
No copy-pasting IDs. No searching. You start where you are.

Remember the in-context customization we showed earlier? The lightning bolt, pick a template, done?

————-CLICK———————

Technical users can go further. Instead of picking a template, they can choose to create a custom automation – and that launches the full Modeler.

But here’s the key: it launches with context. The form ID you were on, the field name you clicked – those are passed as pre-configured context variables.

So when you add an event that listens to that form, or an action that targets that field, the Modeler fills in those configuration parameters automatically.

No copy-pasting machine names. No searching through lists. You start where you are, and the Modeler knows where you came from.

This bridges the gap between the simple in-context experience and the full power of the Modeler.

Watch this. We’re back on our form. Click the lightning bolt. But this time, instead of picking a template, we choose to create a custom automation.

The Modeler opens – and look: the context is pre-selected.

Now I add an event. Only form related events are available. See how the form parameter is already filled in?

And when I add an action for this field – the field name is pre-populated.

This is what it means to start from context. The Modeler meets you where you are.

But there is more: the model doesn’t close accidently.

And back on the form, ECA now exposes if is was involved in processing the current page. See the logo bottom right.

The model then only shows that selected event, the rest of the model is still there but not visible.

And the replay data from tha context where you cam from is already loaded into the panel. Start debugging right away.

Accessibility

WCAG AA compliant

Full keyboard navigation
Screen reader support (ARIA labels, live regions)
Focus management & focus trapping
Dark mode (light and dark meet contrast requirements)

High contrast mode (OS preference)
Reduced motion (OS preference)
44px minimum touch targets
Confirmation dialogs for destructive actions
Automated axe-core testing on every component

For Developers

Extensibility

Plugin API

Modeler API provides:

Model Owner API
Modeler API
Context API
Dependency API
Template Token API
Test / Replay / Debug Framework

Modeler provides:

Plugin API for additional panels
Plugin API for toolbar widgets
Plugin API for custom behaviors
Plan: Integrate with an AI Agent

Standalone Viewer

How It Got Built

Three years on the to-do list

Pittsburgh, 2023.

Three years of knowing what Drupal needed.

Three years of knowing how to build it.

Three years of never having the time.

The numbers

6 weeks / ~200 hours

~90,000 lines of code

300+ commits

1 developer

Full test coverage

WCAG AA accessibility

Extensive UX expert input

All documentation written

Documentation

ecaguide.org

Modeler API

Modeler

Code quality

Every merge request passes 15 automated quality gates – no exceptions.

3,617 test cases with 5,571 assertions
1.9x more test than production code
Zero-tolerance in 15 CI gates
3 test layers: unit, E2E, accessibility
PHPStan level 6, TypeScript strict mode
35 stories axe-core audited (WCAG AA)

This is production-ready. It’s tested. It’s documented.

And it’s open for contributions.

Let me prove it.

I’m tagging the 1.0.0 release of the Modeler – right now, live.

Links

Slides go.lakedrops.com/eca-chicago-2026

ECA processor drupal.org/project/eca
Modeler API drupal.org/project/modeler_api
Modeler drupal.org/project/modeler
BPMN.iO drupal.org/project/bpmn_io

ECA Starter Kit drupal.org/project/eca_starterkit

ECA Guide ecaguide.org
Modeler API Docs project.pages.drupalcode.org/modeler_api
Modeler Docs project.pages.drupalcode.org/modeler

Drupal Slack #ECA channel drupal.org/slack
Find me online go.lakedrops.com/jurgenhaas

Q&A

Thank you!

go.lakedrops.com/eca-chicago-2026