ECA - The Power Tool in The House

Drupal Automation and Customization for Everyone

Drupal Camp Burkina Faso 2026
go.lakedrops.com/burkina-faso-2026

Jürgen Haas

29. May 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

Getting Started - The “aha!” moment
Going Deeper - Show the power
Show the Effect - Make it real
Documentation - ECA Guide
Plugin Reference - The toolkit
ECA Ecosystem - The bigger picture
Architecture & Quality - Build trust
When to Use ECA - Practical guidance
Complex Applications - Beyond basics
Roadmap & Community - How to help
Conclusion - The takeaway

go.lakedrops.com/burkina-faso-2026

⏱️ TIME: 1:00

Journey starts with a user perspective.

Solving a real problem.

Getting into more complex scenarios afterwards.

Architecture, ecosystem, quality gates.

You can learn:

when to use ECA, and when not
where this journey is going
hoe you can help

There will be time for questions at the end. But you can interrupt at any time, if you wish.

Here’s our journey today. We’re going to start simple and build up.

First, I’ll show you the “aha!” moment - that instant when you realize “I can do this!”

Then we’ll go deeper into the power available to you.

We’ll see real effects - not just theory, but actual working examples.

I’ll show you the comprehensive documentation at ecaguide.org - your path to independence.

We’ll look at the ecosystem - what’s available, who’s using it, what you can build.

We’ll talk about architecture and quality - because trust matters.

We’ll discuss when to use ECA versus other approaches.

We’ll look at complex applications - what’s possible beyond the basics.

Finally, we’ll talk about the roadmap and how you can get involved.

This is about 51 minutes of content, then we’ll have up to 9 minutes for your questions.

Let’s begin!

Getting Started

The “aha!” moment

The scenario

You have:

A fresh Drupal site
A form you want to customize
An idea of what you want to happen

You need:

To change field labels
To add validation
To make it work differently for different users

Three approaches:

Write PHP code
The traditional way

Use ECA with the visual modeler
The technical user way

Use in-context customization
The everyone way

⏱️ TIME: 1:00

… content from slide …

Let me show you what this looks like.

Here’s what you have: a Drupal site, a form, and an idea.

You want to change field labels, add validation, make things behave differently.

How do you do it?

————-CLICK 1———————

Traditionally, you’d write PHP code. Create a hook. Write validation logic. Deploy a module.

If you’re a developer, this works. But it takes time. And most people can’t do it at all.

————-CLICK 2———————

With ECA, you can use the visual modeler. No PHP needed. Build workflows with drag and drop.

This is powerful and accessible to technical users. But there’s still a learning curve.

————-CLICK 3———————

But now, with in-context customization, you don’t even need to open a workflow editor.

You customize right on the page. Pick a template. Configure it. Done.

Let me show you what this looks like.

In-context customization

⏱️ TIME: 3:00

Instead of a video, let’s do that live …

Mail / Name / Admin Role

Currently available for forms, will be made available elsewhere soon.

[DEMO - Narrate the video]

Watch this carefully. You’re looking at a regular Drupal form.

I focus on a field - any field. See that? A lightning bolt icon appears.

Click it. What you’re seeing now are ECA templates. These are pre-built automations.

Each one does something useful: change the label, make a field required, hide it based on conditions.

Pick one - let’s say “Set label”. A simple form appears.

Type your new label. Click save.

That’s it. Done.

The field label changed. No admin screens. No workflow editor. No configuration forms.

You didn’t need to know what an “event” is, or a “condition”, or an “action”.

You just pointed at what you wanted to change, picked what you wanted to do, and it happened.

This is in-context customization. ECA power without ECA complexity.

Right now, this works for forms. But we’re bringing it to everything - redirects, rendering, access control, you name it.

Imagine the same lightning bolt on login pages, on entity displays, on views.

Point, click, customize. That’s the vision.

No Drupal knowledge needed

Before in-context customization:

Open admin menu
Navigate to ECA section
Create new model
Choose event
Configure conditions
Add actions
Save and test

With in-context customization:

Focus the element
Click the lightning bolt
Pick a template
Fill in the details
Save

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

Going Deeper

What happens when you want more?

From context to modeler

⏱️ TIME: 3:00

Demo instead of video …

Name field -> modeler

Add new event === form ID pre-filled

Add new field action === field ID pre-filled

Save -> Close modeler -> back to form -> refresh

ECA exposes where it was involved -> open modeler from bottom right

Filtered view, explain

Show replay and debugging

[DEMO - Narrate the video]

We’re back on our form. Same lightning bolt.

But this time, instead of picking a template, we choose “Create custom automation.”

Watch what happens.

The modeler opens. But it’s not a blank canvas - it already knows where you came from.

See that? The form ID is pre-filled. The field name is already there.

When I add an event - “Form is being built” - the form parameter is automatically set to the form I was looking at.

When I add an action - “Set field label” - the field name is pre-populated.

The modeler meets you where you are.

Now I can build complex logic:

If the user has a certain role, change the label this way
If the user doesn’t have that role, change it a different way
Add validation rules
Show or hide fields
Change the entire form structure

All visually. All with drag-and-drop.

But I didn’t have to start from scratch. I started from context.

And look at this: back on the form, ECA now shows that it was involved in processing this page.

See that logo in the bottom right? Click it.

The modeler opens again - but only showing the events that were relevant to this page.

The rest of the model is still there, but hidden for clarity.

And the replay data from the context where you started is already loaded.

You can start debugging immediately.

This is the bridge. Simple when you need simple. Powerful when you need power.

Example: Role-based field labels

The use case:

You want form field labels to be different based on user role.

Administrators see technical field names
Regular users see friendly descriptions
Anonymous users see even simpler text

Without code: Build this in the modeler with conditions and actions.

The flow:

Event: Form is being built
Condition: Current user has role “administrator”?
- Yes: Set label to “Field: user_email_address”
Condition: Current user has role “authenticated”?
- Yes: Set label to “Your email address”
Else: Set label to “Email”

Visual, testable, maintainable.

⏱️ TIME: 2:00

This is extremely powerful. Let’s take it another step forward.

Explain the example use-case from the slide

Here’s a concrete example that would take custom code in traditional Drupal.

You want the same field to have different labels for different user roles.

Administrators see the technical field name - they need precision.

Regular users see friendly descriptions - they need clarity.

Anonymous users see the simplest possible text - they need speed.

In the modeler, this becomes a simple flow:

Event: “Form is being built” - triggered every time the form loads
Condition: Check the user’s role
Action: Set the label based on that role

You can see this. You can test this. You can modify this.

No PHP. No custom module. No deployment complexity.

Just visual logic that anyone can understand.

Show the Effect

Make it real

Testing with different users

⏱️ TIME: 3:00

Demo instead of video …

Go to ECA admin page -> explain that I have prepared the complex model in advance

Disable the simple form model -> enable the complex form model -> open the complex model

Explain what the model does and how

Click “TEST” and let ECA wait for the event to happen

Call “DRUSH CR” and go to register as anonymous user

Go back to ECA and show that the data was loaded => step through and show the visual flow

Click “TEST” again …

As admin, open “User create” and go back to the model => step through the extra steps

[DEMO - Narrate the video]

Here’s the magic: test, replay, and debug - all in one screen.

Watch this. I’m in the modeler. I’ve built a workflow.

Click “Test”. The system fires the event - right here, in the modeler.

I can see the flow executing. Each step lights up as it runs.

Conditions are evaluated. Actions are performed.

But here’s the powerful part: I can see the token values - the actual data - at each step.

What’s the current user? What’s the form ID? What values are available?

All visible. All inspectable.

Now watch this: I can record this test. Create a replay file.

Later, I can load that replay. See exactly what happened. Compare different scenarios.

“What did the flow do for User A versus User B?”

“Why did this condition evaluate to false?”

“What data was available at this step?”

All answerable. All debuggable.

This is unprecedented. No other workflow tool in any CMS does this.

You build, test, and debug in one place. No switching contexts. No guessing.

Debugging flow execution

See exactly what happened:

Which events fired
Which conditions evaluated true/false
Which actions were executed
What data was available at each step

Load recorded data:

From live production events
From test scenarios
Compare different users
Compare different contexts

The power:

You can answer questions like:

“Why didn’t this action run?”
“What was the user role when this happened?”
“What values were in the form?”
“Did the condition work as expected?”

All visually. All without adding debug statements to code.

Documentation: ECA Guide

Your path to independence

ecaguide.org & Library

What’s in the Guide:

Getting started tutorials
Complete plugin library with 1,000+ plugins
100+ sample models you can import
Video tutorials and step-by-step guides

The Library: Your Starting Point

Browse working examples. See them in the standalone viewer. Export as JSON. Import into your site.

You don’t build from scratch - you adapt working examples.

Everything you need at ecaguide.org

⏱️ TIME: 2:00

Regular documentation but also …

There is so much, let’s look at it live.

Open ECA Guide => all about ECA => all about modelers => all plugins => a sample library => and …

Resources => highlight tutorials in the sidebar

… and the videos from the resource intro

The ECA Guide at ecaguide.org is your path to mastery.

Getting Started tutorials walk you through installation and first models.

The Plugin Library documents all 1,000+ events, conditions, and actions. Searchable and cross-referenced.

But the crown jewel is the Library: over 100 complete, working sample models.

Need to send email when content is published? There’s a sample.

Want role-based login redirects? There’s a sample.

Each model can be viewed in the standalone viewer - no Drupal needed. You see the complete workflow, explore the configuration, understand how it works.

Like it? Export as JSON. Import into your site. Boom - working automation.

Modify it for your needs. Add conditions. Change actions.

This is how real learning happens: from concrete examples, not abstract theory.

And it’s all free, open, and actively maintained.

Plugin Reference

The comprehensive toolkit

The comprehensive toolkit

Over 1,000 plugins available

~250+ Events

Entity operations, form lifecycle, user actions, cron, Commerce, Webform, custom events

~120+ Conditions

User/role checks, entity comparisons, field values, dates, complex logic (AND/OR/NOT)

~650+ Actions

Entity manipulation, field operations, email, redirects, tokens, queues, cache operations

All documented

In the ECA Guide:

Search by keyword
Filter by type and module
See token relationships
Navigate backlinks
Usage examples

In the Modeler:

Context-aware filtering
Only relevant plugins shown
Help text for every parameter
Token browser with drag-and-drop
Dependency-aware suggestions

The system guides you

The challenge:

1,000+ plugins could be overwhelming

The solution:

The system doesn’t show you 1,000 options.

It shows you the relevant 10 based on:

Your current context
Available data/tokens
Dependencies
What makes sense

ECA Ecosystem

The bigger picture

ECA Core: Lean and focused

The processor engine:

Plugin system (events, conditions, actions)
Token integration
Model storage & execution
Recording/replay infrastructure
Test & debug framework

Only 1 dependency:

Drupal Core

That’s it. Nothing else.

20 sub-modules: Enable what you need

Common sub-modules:

eca_base - Core functionality (cron, custom events, tokens, state)
eca_content - Entity operations (CRUD, field manipulation)
eca_form - Form lifecycle (build, validate, submit, alter)
eca_user - User events (login, logout, roles)
eca_views - Views integration & queries

Specialized sub-modules:

eca_access - Entity & field access control
eca_cache - Cache operations
eca_endpoint - Custom HTTP endpoints
eca_workflow - Content moderation
eca_queue - Async processing
eca_ui - Modeler interface

+ 9 more

80+ integrations

Contributed modules extending ECA:

AI Integration - OpenAI, local models
Commerce - Orders, payments, cart
Webform - Submission workflows
Flag - Flagging actions
Easy Email - Template-based emails

Group - Group operations
Maestro - Workflow collaboration
Tamper - Data transformation
Entity Share - Content distribution
+ 70 more modules

The numbers

Production usage:

17,000+ active installations
1,000+ plugins available
100+ sample models in Library
Active community in Drupal Slack #eca

Why it matters:

People are using this in production.

For real work. Solving real problems.

This is the most powerful automation engine in any CMS.

Architecture & Quality

Why you can trust it

The architecture

Two modelers, one system

BPMN.iO Modeler

BPMN 2.0 standard
Powerful, technical
Used since 2021
Still supported
For Drupal 10 & 11

Workflow Modeler (NEW)

React Flow-based
Modern, accessible
Context-aware
Test/replay/debug built-in
Requires Drupal 11.3+

⏱️ TIME: 0:45

Modeler are the UI, what we saw on the right side of the diagram

Up until early this year, there was only 1 that looked like BPMN

In March this year we launched a second one, which is more modern and fully accessible

The new modeler only works on Drupal 11.3 and later, so this is the future

You have a choice of modelers.

The BPMN.iO modeler has been with ECA since 2021. It’s powerful, follows the BPMN 2.0 standard, and works with both Drupal 10 and Drupal 11.

The new Workflow Modeler launched in 2026. It’s built with React Flow, has a modern accessible interface, context-aware filtering, and integrated test-replay-debug capabilities.

Important note: The new Workflow Modeler requires Drupal 11.3 or higher. If you’re still on Drupal 10, use the BPMN modeler.

Both edit the same models. You can even switch between them - the models are lossless.

Modeler quality

The new Workflow Modeler:

3,617 test cases, 5,571 assertions
1.9x more test code than production code
15 CI gates, zero tolerance
PHPStan level 6, TypeScript strict

3 test layers: unit, E2E, accessibility
WCAG AA compliant
35 component stories audited
This is production-grade engineering.

ECA quality & support

ECA Core:

High test coverage
Active maintenance since 2021
Regular updates
Stable API, backward compatible
Over 17,000 production installations

Platform support:

Drupal 11.3+
full features, new Modeler - PHP 8.3+
Drupal 10
supported, BPMN modeler - PHP 8.1+
Drupal 12
ready - coming late 2026 - PHP 8.5+
Config entities:
sync, version control, deployment

⏱️ TIME: 0:30

But also ECA itself has great test coverage

And usually ZERO bugs in the issue queue

If a bug is found, we usually fix that within days, but that doesn’t happen too often

What’s important: ECA models are config entities => YAML files

That means, they don’t break with new versions of Drupal or Symfony, or anything else

ECA itself has high test coverage, active maintenance since 2021, regular updates.

The API is stable and backward compatible. Over 17,000 installations in production.

Platform support: Full features including the new Modeler on Drupal 11.3+.

Drupal 10 is still supported - you’ll use the BPMN modeler there, which is powerful and proven.

And ECA is already ready for Drupal 12, which is coming later this year.

PHP 8.1 and higher.

All models are config entities, so they work with config sync, version control, and your deployment pipelines.

Built for extensibility

Modeler API:

Build custom modelers
Create templates
Context & dependency systems
Test/replay/debug framework

ECA Plugin APIs:

Custom events, conditions, actions
Token integration
State & variable systems
Integrate external systems

When to Use ECA

Practical guidance

ECA vs. Custom Code

Should I write custom code or use ECA?

Answer: Use ECA.

Why?

Faster to build
Visual and testable
Maintainable by non-developers
Transparent to clients
Config entities (easy deployment)
No code to maintain
Documented by its own structure

When to write custom code instead:

Complex algorithms (math-heavy, performance-critical)
Deep Drupal core integration
Something that needs to be a reusable API for other modules

Everything else? ECA.

Site-specific logic. Form alterations. Redirects. Notifications. Validation. Entity manipulation.

All better in ECA.

⏱️ TIME: 2:00

Should you write custom code or use ECA?

Custom code should only ever be the exception

It’s the most expensive piece of the delivery

But if you need customer specific feature …

————-CLICK 1———————

Developers think, they’re faster by writing PHP code

Initially, that may be correct

but long term (10 years!?) the opposite is true

In our experience: with diagrams you get better buy-in from customer’s stakeholders

————-CLICK 2———————

Only if you have to write really complex stuff, then custom code is OK.

Let’s address the question directly.

“Should I write custom code or use ECA for this feature?”

————-CLICK 1———————

Answer: Use ECA.

Why? Because it’s faster to build, visual and testable, maintainable by non-developers.

Clients can see what’s happening. They can understand the logic.

It’s config, so it deploys with your configuration management.

There’s no code to maintain, no security patches to track.

And it’s self-documenting. The model shows what happens.

————-CLICK 2———————

When should you write custom code instead?

Complex algorithms that are math-heavy or performance-critical
Deep Drupal core integration where you’re extending systems
Reusable APIs that other modules need to call

That’s it. That’s the list.

Everything else - site-specific logic, form alterations, redirects, notifications, validation, entity manipulation - is better in ECA.

ECA vs. Other Modules

Should I install a module or build with ECA?

Answer: Use ECA.

Why?

One system instead of many modules
Fewer dependencies to maintain
Fewer updates to track
Custom logic exactly matching your needs
No bloat (modules do 80% of what you want, ECA does 100%)
Transparent logic

When to use a module instead:

Complex UI components (the module provides a whole admin interface)
Established, well-maintained solutions (don’t reinvent the wheel)
Something you’ll use across many sites (recipes can help here too)

But consider:

Many modules can be replaced by a single ECA model.

Redirect modules? ECA can do it. Login redirect modules? ECA can do it. Notification modules? ECA can do it.

Fewer modules = simpler site.

⏱️ TIME: 2:00

But what about contrib modules?

There are well established and maintained modules, everybody should use:

Webforms, Commerce, Groups, Field Types, etc.

————-CLICK 1———————

But so many contrib modules can be avoided …

Why should they be avoided?

Site maintenance, attack vector, dependencies

With ECA, very often you can build the solution with your requirements, and still only have one module: ECA

————-CLICK 2———————

Still, nothing wrong with contrib modules.

But be selective, it will pay back in the long run.

Like we said before: ECA is already compatible with Drupal 12

you could upgrade tomorrow

no reason to wait for all the other modules to become compatible

Here’s another question: “Should I install a module or build with ECA?”

————-CLICK 1———————

Answer: Use ECA.

Why? Because one ECA model replaces many single-purpose modules.

Fewer dependencies. Fewer security updates. Less bloat.

Modules do 80% of what you want. Then you have to configure around the remaining 20%.

ECA lets you build exactly what you need. 100%.

And the logic is transparent. You can see it. Modify it. Understand it.

————-CLICK 2———————

When should you use a module instead?

When it provides a complex UI that would take weeks to build
When it’s an established, well-maintained solution (don’t reinvent the wheel)
When it’s something you’ll use across dozens of sites

But consider: many modules can be replaced by a single ECA model.

Redirect modules? ECA has redirect actions. Login redirect based on role? ECA does it in one model. Email notifications? ECA handles it.

Fewer modules = simpler site. Easier to maintain. Fewer places for problems to hide.

Complex Applications

Beyond the basics

What ECA can do

Application development, not just automation:

Page rendering:

Custom page layouts
Dynamic block placement
Themed output
Context-aware displays

Form building:

Multi-step wizards
Dynamic AJAX interactions
Custom validation
Conditional fields

API endpoints:

RESTful APIs
Webhooks
AJAX handlers
External integrations

System integration:

Maestro multi-user workflows
FlowDrop orchestration
External API calls
Event-driven architecture

⏱️ TIME: 1:00

Rendering

Build forms - not only alter them

Endpoints

Integrate with other systems, internal and external

This is not just customization or automation

This is application development

Let me show you a couple examples …

ECA can render entire pages, not just alter them. Build custom page layouts. Place blocks dynamically. Theme output for specific contexts.

ECA can build complex forms - multi-step wizards, AJAX interactions, custom validation, conditional fields. htmx support is coming soon for modern reactive interfaces.

ECA can create endpoints - RESTful APIs, webhooks, AJAX handlers. External systems can call your Drupal site and ECA processes the request.

ECA integrates with other systems. Maestro for multi-user workflow processes. FlowDrop for external orchestration. ECA is the glue between systems.

This is application development, not just automation.

Production example: SAP Frontend

Built almost entirely with ECA:

Scale:

30-40 user roles
25 node types
20 taxonomies
18 workflow states
Hundreds of ECA models

Capabilities:

Complex validation rules
Access control across entity references
Automated reporting
Multi-step approval workflows
Integration with SAP backend

Serving a global enterprise.

⏱️ TIME: 1:00

A globally operating enterprise

They use Drupal as a SAP frontend, so that they don’t require too many client licenses

The application is extremely complex: roles, node types, taxonomies, workflow statess

100+ ECA models that keep control of data integrity and workflow

Let me show you what’s possible in production.

A global SAP frontend built almost entirely with ECA: 30 to 40 user roles. 25 different node types. 20 taxonomies. 18 workflow states.

Intense validation rules. Access control logic spanning entity references. Automated reporting. Multi-step approval workflows. Integration with SAP backend systems.

Hundreds of visual models working together.

This is a production application serving a global enterprise. Not a toy. Not a prototype. A real business application.

Production example: Booking System

Built entirely with ECA - zero custom code:

Features:

Calendar display
Availability checking
Reservation management
Customer management
Contract generation

Automation:

Multilingual email notifications
Cron-based reminders
Payment tracking
Reporting dashboards
Multi-currency support

Serving real customers, real bookings.

Roadmap & Community

Where we’re going and how you can help

What’s coming

The roadmap:

Developer experience:

Htmx integration for reactive UIs
More in-context customization:
entities, views, login
Sophisticated gateways and loops
Improved custom events to build reusable models
Visual debugging improvements

Community & content:

Enhanced AI agent integration
More Library templates
Community plugin repository
Documentation expansion

Community-driven. Prioritized by real needs.

How you can help

Share your knowledge:

Build templates - share your workflows
Write documentation - tutorials, videos, guides
Spread the word - share success stories

Define intelligence:

Context - which plugins make sense where?
Dependencies - what should follow what?

Make it better:

Test and report - find edge cases, report bugs
Request features - what would help you?
Help others - answer questions in Slack

Not a coder? No problem.

Use ECA, share feedback, help others. Your perspective matters.

⏱️ TIME: 1:00

So, if you’re interested to get involved …

there are opportunities.

And that’s not just for developers, the biggest help is to provide feedback and ask questions.

That helps us to understand what’s need and what we need to improve.

If you are interested in getting your hands dirty, though, we can find something for everyone.

Here’s where we need your help:

Build templates - created a great workflow? Turn it into a template. Share it in the Library.

Write documentation - tutorials, videos, guides. Share what you’ve learned.

Spread the word - share your success stories. Show what you’ve built.

Define context intelligence - which plugins should be available in which situations? Help us make the modeler smarter.

Define dependencies - which actions make sense after which events? Map those relationships.

Test and report - use it, push it, find edge cases, report bugs.

Request features - what would make your work easier?

Help others - answer questions in the Drupal Slack #eca channel.

Not a coder? That’s fine. You can contribute by using ECA, sharing feedback, and helping others.

The community makes ECA better. Your perspective matters.

Getting started

Install the ECA Starterkit recipe on a Drupal 11.3+ site:

Quick setup:

# Install the recipe
composer require drupal/eca_starterkit

# Apply it to your site
drush recipe ../recipes/eca_starterkit

That’s it. You’re ready.

What you get:

ECA Core + essential sub-modules
Workflow Modeler
Sample models from the Library
Working examples you can explore
Everything configured, ready to use

Start exploring immediately.

⏱️ TIME: 1:00

… talk them through how simple it is to get started …

Getting started with ECA is simple thanks to the ECA Starterkit recipe.

First, require it with composer: composer require drupal slash eca underscore starterkit.

Then apply the recipe: php core slash scripts slash drupal recipe eca underscore starterkit.

That’s it. Two commands.

What do you get?

ECA Core plus the essential sub-modules you need. The Workflow Modeler if you’re on Drupal 11.3 or higher, otherwise the BPMN modeler. Sample models imported from the Library. Working examples you can explore and modify.

Everything is configured and ready to use.

You can start exploring immediately. Open the Modeler. Browse the samples. Pick one. Modify it. See what happens.

Links to documentation and community resources are on the next slide.

Conclusion

ECA brings Drupal power to everyone.

Not just developers. Not just technical users. Everyone.

In-context customization for end users
Visual modeling for site builders
Extensible architecture for developers
AI integration for the future
Production-ready with 17,000+ installations

The power tool is in your house. It’s time to use it.

⏱️ TIME: 2:00

Time to wrap this up.

Drupal as a CMS, as a platform, as a web-framework, … IS GREAT

It built to be extended, modified, improved, and shared.

ECA is the power tool that allows so many more people to get involved and do a lot themselves.

Simple when you need simple. Powerful when you need power.

That’s the promise of ECA: Drupal automation for everyone.

Let me bring this home.

ECA is about democratizing Drupal.

For too long, customizing Drupal meant writing code. That excluded most people.

ECA changes that.

End users get in-context customization. Point, click, configure. No Drupal knowledge needed.

Site builders get visual modeling. Build complex workflows without code.

Developers get extensible architecture. Build plugins. Integrate systems. Extend the platform.

And AI integration means even the learning curve is optional. Describe what you want. Get a working model.

This is production-ready. 17,000+ sites are using it. Real businesses. Real problems solved.

The power tool is in your house.

Drupal has always been powerful. But that power was locked behind code.

ECA unlocks it. Makes it accessible. Visual. Testable. Maintainable.

Whether you’re building a simple form alteration or a complex application, ECA meets you where you are.

Simple when you need simple. Powerful when you need power.

That’s the promise of ECA: Drupal automation for everyone.

Links

Slides go.lakedrops.com/burkina-faso-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/burkina-faso-2026