What is Ecotone Framework?

Ecotone is the PHP framework for durable workflows, event sourcing, Domain-Driven Design, reliable messaging, and asynchronous communication — one Composer package that adds sagas, orchestrators, aggregates, projections, outbox, retries, and CQRS to Laravel or Symfony through declarative PHP attributes. It runs on the database and broker you already operate; no separate workflow service, no replay-deterministic DSL, no engine-specific event log.

Do I need Temporal or a separate workflow engine to build durable workflows in PHP?

No. Ecotone delivers durable execution on the database and broker you already run. Sagas persist state per identifier, chained workflows survive crashes through the outbox plus async channel, saga timeouts use a #[Delayed] attribute, and Orchestrators (Enterprise) give declarative multi-step workflows. There is no separate cluster to operate, no RoadRunner or ext-grpc requirement, no replay-deterministic DSL — workflows are plain PHP classes with attributes. If you have already adopted Temporal, Ecotone still fits around it for CQRS, projections, distributed messaging, multi-tenant routing, and sagas that aren't full workflows.

Which message brokers does Ecotone work with?

RabbitMQ, Apache Kafka, Amazon SQS, Redis, and the database (DBAL outbox) are first-party — and Ecotone also integrates with Enqueue transports, Symfony Messenger transports, and Laravel Queue channels. Handler code is broker-agnostic: a single #[Asynchronous('channel')] attribute works the same across every transport. CombinedMessageChannel writes the message to the database for the outbox guarantee and dispatches execution on the broker, so outbox draining stays on the database and consumers scale horizontally on RabbitMQ / SQS / Kafka.

Can I use Ecotone with Laravel or Symfony?

Yes. Ecotone ships dedicated packages for both Laravel and Symfony that make integration seamless. After installation, Command, Event, and Query buses are available out of the box in the dependency container — and for any other framework, Ecotone Lite provides a standalone integration via PSR-11.

Do I need to rewrite my application to use Ecotone?

No. Ecotone works alongside your existing application — you adopt it incrementally for the parts where messaging, sagas, event sourcing, or distributed messaging make sense, without rewriting what already works. Ecotone sits above Symfony Messenger and Laravel Queues, using them as transports underneath rather than replacing them.

Why pick Ecotone over Spatie laravel-event-sourcing, EventSauce, or Patchlevel for event sourcing?

Ecotone provides a built-in event store on PostgreSQL or MySQL with #[EventSourcingAggregate], #[ProjectionV2] for read models (global, partitioned, or streaming), default-on gap detection so concurrent-transaction events aren't silently skipped, projection emission via EventStreamEmitter with rebuild auto-suppression, and end-to-end PII encryption across the event store, broker payloads, and structured logs. Compared to Spatie laravel-event-sourcing (Laravel-only, single-process rebuild, no gap detection), EventSauce (no subscription engine, shared-envelope dispatch), and Patchlevel event-sourcing (single-cursor per projection, encryption stops at the event-store boundary), Ecotone covers the operational axes that matter for high-volume event-sourced systems.

Does Ecotone support building systems following Domain-Driven Design?

Ecotone's vocabulary is DDD vocabulary: #[Aggregate], Repository abstraction, #[Saga] as process managers, bounded-context isolation via the Distributed Bus, and Domain Events as first-class plain PHP classes. Where each building block is fully decoupled from the framework using declarative configuration. Ecotone is the only framework that makes DDD build blocks easily composable in Message-Driven systems, to not only ensure clear business logic, but to make the system build on top of reliable architecture.

Domain-Driven Design in PHP

#[Aggregate], #[AggregateIdentifier], aggregate command handlers, repository abstraction, #[Saga] as process managers, bounded-context isolation via Distributed Bus, Domain Events as first-class plain PHP classes.

Domain-Driven Design — full guide Install Ecotone

Composer package · Laravel or Symfony · PostgreSQL or MySQL · RabbitMQ, Kafka, SQS, Redis, or DBAL outbox

What Ecotone provides

Capabilities relevant to domain-driven design

CQRS & Handlers

Command, query, and event bus — all auto-wired from your attributes. No registration, no factory classes, no container bindings.

Event Sourcing & Projections

Store events, not state. Aggregates, projections, replay, snapshotting. Partitioned + streaming projections so rebuilds parallelize across workers and catch up in real time — no single-process bottleneck.

Sagas & Workflows

Stateful long-running processes with compensation. Handler-chaining workflows for stateless pipelines. Saga timeouts in one #[Delayed] attribute. All declarative, all attribute-driven.

Compose Patterns Without Glue

Aggregate publishes event. Saga subscribes by attribute. Projection subscribes by attribute. Async handler subscribes by attribute. The attribute is the wiring.

Framework-portable Business Code

Same aggregates, handlers, sagas, and projections run on Laravel, Symfony, or any PSR-11 container. Hedge against framework changes over a decade.

How it compares

PHP alternatives for this category

Each row names what you'd need to add to match Ecotone, and the architectural ceiling that integration cannot fix.

Spatie laravel-event-sourcing

An event-sourcing library, not a DDD framework. Laravel-only.

Aggregates extend `Spatie\EventSourcing\AggregateRoots\AggregateRoot`; every domain event must implement the marker interface `ShouldBeStored` — infrastructure bleeds into the domain model.
Read models extend the package's Eloquent-backed `Projection` class.
Laravel-only — no Symfony parity, no standalone container option.
Covers the ES slice of tactical DDD; everything around it (CQRS message buses, saga as process manager, bounded-context distribution, outbox, distributed bus, multi-tenant routing) is your responsibility to assemble from other libraries.
No saga / process-manager primitive — Reactors run on live events only, with no identifier-mapped state machine that lives across events arriving over time.

EventSauce

Cleanest DDD ergonomics — but a library, not an architecture.

Best DDD ergonomics among pure-ES PHP libraries — no marker interface on events, aggregates use `AggregateRootBehaviour` trait (composition not inheritance), well-documented snapshotting.
No CQRS message-bus primitive — bring your own dispatcher.
No saga as process manager — process managers are plain `MessageConsumer` implementers you wire yourself.
No bounded-context distribution (no Distributed Bus / Service Map equivalent), no orchestrator, no shared middleware across building blocks.
The DDD vocabulary Ecotone delivers on one model is five-to-six separate library decisions on top of EventSauce.

Patchlevel event-sourcing

Strong attribute-based aggregates — but an ES package, not a DDD architecture.

Strong attribute-based modelling (`#[Aggregate]`, `#[Id]`, `#[Apply]`, `#[Event]`, `#[Stream]`, `#[AutoInitialize]`) with Stream-splitting and Micro-Aggregates for large aggregates.
An event-sourcing package — no saga as a first-class process manager (no identifier-mapped state machine across events arriving over time).
No bounded-context distribution (no Distributed Bus / Service Map equivalent), no messaging primitives, no async dispatch, no orchestrator.
**Production-critical failure mode:** the subscription engine advances position but doesn't isolate failure per partition — one failing handler blocks the whole processing pipeline.
Tightly coupled to Doctrine DBAL; Symfony bundle is first-party, Laravel is not officially supported.

Ecotone

DDD vocabulary as PHP attributes — no base classes, no DSL between domain and framework.

Aggregates as plain final classes with `#[Aggregate]`.
Event-sourced aggregates with `#[EventSourcingAggregate]` and `#[EventSourcingHandler]` event-application methods.
Sagas as process managers via `#[Saga]` with `#[Identifier]` mapping events to instances by payload field, header, or expression.
Bounded contexts isolated operationally by the Distributed Bus + Service Map — strategic DDD made operational, not aspirational.
Domain Events as first-class plain PHP classes — no `recordThat()` mixin, no `DomainEventInterface` to implement, no library-specific event dispatcher to wire.
Repository abstraction via the inbuilt DBAL or Eloquent repository, or your own implementation.
The four tactical-DDD building blocks (aggregates, sagas, projections, domain events) live on one declarative model — same EcotoneLite testing harness across all four, same retry / dedup / PII / observability middleware applied uniformly, no inter-library wiring to reconcile.

Read the Domain-Driven Design guide

Frequently asked questions

Haven’t found what you’re looking for? Contact us

Ecotone's vocabulary IS DDD vocabulary — #[Aggregate] for state-stored aggregates, #[EventSourcingAggregate] for event-sourced ones, aggregate command handlers via #[CommandHandler] directly on aggregate methods, repository abstraction via DBAL or Eloquent or your own implementation, #[Saga] as process managers with #[Identifier] mapping events to instances, bounded-context isolation via the Distributed Bus + Service Map, Domain Events as first-class plain PHP classes (no marker interface). PHP's historical DDD libraries are dormant: Broadway's last functional release was May 2023 (subsequent commits are CI / dependency bumps); Prooph's `event-sourcing` and `service-bus` packages have not received a commit since 2021, and the project website is frozen at 2019. Ecotone is the actively-maintained tactical-DDD framework on Laravel, Symfony, and Ecotone Lite.

Plain final classes. #[Aggregate] marks the type, #[Identifier] declares the identity, command handlers live on the aggregate (a static factory for creation, an instance method for state-changing operations). No base class, no interface, no recordThat() mixin required. Domain events are plain PHP classes the aggregate records; Ecotone publishes them onto the event bus when the aggregate is persisted.

The Distributed Bus and Service Map move commands and events between PHP services over the brokers you operate. Each bounded context runs as its own deployable with its own database, communicating with other contexts via well-defined domain events on the bus. The translation between contexts becomes explicit: events emitted by Context A are subscribed to by translators in Context B using #[Distributed] handlers on each side. Strategic DDD made operational.

A #[Saga] is a process manager in Vernon's sense — it remembers state across events arriving over time, decides what to do next, and dispatches commands to keep the process moving. State persisted per #[Identifier]; on each event arrival, Ecotone reloads the saga from the database. Event-to-saga binding via payload field, header, or expression (identifierMapping). #[Delayed] handles saga timeouts without cron.

Be part of the change with Ecotone

Unleash the power of Messaging in PHP
and push productivity to the higher level

Get started