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, Symfony, or Tempest 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, Symfony, or Tempest?

Yes. Ecotone ships dedicated packages for Laravel, Symfony, and Tempest 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 for Event Sourcing?

Ecotone provides a built-in event store on PostgreSQL or MySQL with #[EventSourcingAggregate], #[ProjectionV2] for read models (global, partitioned, or streaming), non-blocking gap detection that catches concurrent-transaction events without blocking concurrent writes, projections that can publish their own events so dependents react in the same flow instead of a separate eventually-consistent process (with rebuild auto-suppression), and end-to-end PII encryption across the event store, broker payloads, and structured logs. As event volume grows, projections scale from a single cursor to N parallel workers via partitioning — without changing your domain code.

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, Symfony, or Tempest · 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, Tempest, or any PSR-11 container. Hedge against framework changes over a decade.

How it compares

What Ecotone adds over a single-purpose tool

Each tool below is a capable choice for its slice. Ecotone covers the same ground and adds the operational layer around it — so aggregates, projections, sagas, and messaging share one model and one set of guarantees.

Spatie laravel-event-sourcing

Ergonomic event sourcing for Laravel domains.

Where Ecotone goes further than this library

Ecotone expresses the full tactical-DDD vocabulary as attributes — #[Aggregate], #[EventSourcingAggregate], command handlers on aggregate methods — on Laravel or Symfony.
#[Saga] adds an identifier-mapped process manager that lives across events arriving over time.
Repository abstraction over DBAL, Eloquent, or your own implementation.
Bounded-context isolation via the Distributed Bus + Service Map.
CQRS buses, the outbox, and async messaging come in the same model rather than as separate libraries.

EventSauce

Clean DDD ergonomics with trait-based aggregates.

Where Ecotone goes further than this library

Ecotone wraps the same aggregate and event-store ergonomics in CQRS buses, sagas, and distribution — one model, no separate dispatcher to wire.
#[Saga] as a first-class identifier-mapped process manager.
Bounded-context distribution via the Distributed Bus + Service Map.
Shared middleware — retry, DLQ, idempotency, PII, OpenTelemetry — applies across every building block uniformly.

Patchlevel event-sourcing

Strong attribute-based aggregate modelling.

Where Ecotone goes further than this library

Ecotone shares the same attribute-driven modelling and adds the surrounding architecture: CQRS buses, sagas, orchestration, and cross-service distribution.
#[Saga] as a first-class identifier-mapped process manager across events arriving over time.
Bounded-context distribution via the Distributed Bus + Service Map.
Runs on Laravel, Symfony, Tempest, or Ecotone Lite, with shared retry / DLQ / idempotency / PII middleware across every building block.

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). Assemble the same tactical patterns from separate libraries and you own the glue between them — the repositories, the event store, the saga state, the bus wiring. Ecotone delivers them as one actively-maintained model on Laravel, Symfony, Tempest, 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