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.

Event Sourcing in PHP

Event-sourced aggregates with #[EventSourcingAggregate]. Projections via #[ProjectionV2] — global, partitioned, or streaming. Non-blocking gap detection — concurrent access is never blocked. Projection emission with rebuild auto-suppression. End-to-end PII encryption across event store, broker, and structured logs.

Event Sourcing — 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 event sourcing

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.

Projections That Publish Their Own Events

A projection can publish its own event the moment it applies a change — so dependent logic reacts in the same flow instead of a separate eventually-consistent process; sagas, event handlers, and other projections subscribe via the normal #[EventHandler]. Rebuild a projection? Emission is automatically suppressed, so downstream consumers aren't flooded with duplicate historical events while the read model catches up.

Blue-Green Projection Rebuild

Rebuild a projection on a new version in parallel — concurrent async backfill partitioned by aggregate ID scales rebuilds to millions of events across N workers. The live projection keeps serving queries until the atomic flip.

Self-Healing Projections

Projections are trigger-based: on every run they read from the Event Store at their last committed position. Crash at event #42? Fix the bug, deploy, and the projection catches up automatically — no manual reset, no backfill script.

End-to-end PII Protection

One #[Sensitive] attribute encrypts a field in the event store, on the wire over RabbitMQ / SQS / Redis / Kafka / DBAL outbox, and in your structured logs — because all serialization flows through one shared conversion pipeline.

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

Purpose-built for event sourcing inside a Laravel application.

Where Ecotone goes further than this library

Ecotone runs the same event-sourced aggregates, projections, snapshots, and replay — on Laravel or Symfony — and adds the operational layer for scale on top.
Non-blocking gap detection catches concurrent-commit events without blocking concurrent writes — late commits are never silently skipped.
Partitioned, parallel-worker rebuild across N workers — where a single-cursor replay processes the whole stream in one pass.
Projections can publish their own events as they apply changes — downstream read models and processes update in the same flow, avoiding an extra eventually-consistent hop. Automatically suppressed during a rebuild.
End-to-end PII encryption follows one #[Sensitive] field through the event store, the broker, and your structured logs.

EventSauce

A clean, framework-agnostic event-sourcing library.

Where Ecotone goes further than this library

Ecotone wraps the same event-sourcing core in one attribute-driven model that also delivers CQRS buses, async messaging, sagas, and cross-service distribution — without wiring separate libraries together.
A subscription engine that tracks each consumer's position for you.
Per-projection failure isolation — each projection gets its own copy of the event, so one failing projection never holds up the others.
Non-blocking gap detection that never blocks concurrent access, plus projections that can publish their own events — so dependents react in the same flow rather than via a separate eventually-consistent process.
End-to-end PII encryption across the event store, the broker, and your logs.

Patchlevel event-sourcing

A capable Doctrine-based event-sourcing library with per-subscription isolation.

Where Ecotone goes further than this library

Ecotone covers the same event-sourcing ground and adds the wider messaging fabric around it — a cross-service distributed bus, orchestration, and async across any broker.
Partitioned, parallel-worker rebuild within a single projection for very large streams — beyond a single cursor.
Non-blocking gap detection, on by default — concurrent access is never blocked.
End-to-end PII encryption that follows the field beyond the event store — across broker payloads and structured logs.
Projections can publish their own events as they update — dependent read models, sagas, and handlers react in the same flow instead of through a separate eventually-consistent process. Auto-suppressed during a rebuild so backfills don't re-fire them.

Ecotone

Scales with your event volume — from one cursor to N parallel workers.

Covers what every PHP event-sourcing library covers — event-sourced aggregates, projections, snapshots, replay — and adds the operational layer they don't.
Global tracked projections work for the early-stage system. As volume grows, switch to partitioned projections that rebuild in parallel across N workers: 50 million events that take 14 hours on a single-cursor rebuild finish in minutes when partitioned across 60 workers.
Streaming projections consume directly from Kafka or RabbitMQ Streams.
Blue-green deployments host the new projection version alongside the old one — atomic switch when ready, zero downtime.
Non-blocking gap detection catches concurrent-commit events without blocking concurrent writes, before they're silently skipped.
End-to-end PII encryption follows the same #[Sensitive] field through the event store, the broker, and your structured logs.

Read the Event Sourcing guide

Frequently asked questions

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

Ecotone provides a built-in event store on PostgreSQL or MySQL, event-sourced aggregates via #[EventSourcingAggregate], and projections via #[ProjectionV2] with global, partitioned, and streaming variants. Non-blocking gap detection means concurrent-transaction commits aren't silently skipped, without blocking concurrent writes. Projections can publish their own events as they update — so dependent read models, sagas, and handlers react in the same flow instead of through a separate eventually-consistent process; emission is automatically suppressed during a rebuild so consumers aren't flooded with historical duplicates. End-to-end PII encryption follows a single #[Sensitive] field through the event store, the broker payload, and your structured logs. As event volume grows, projections scale from a single cursor to N parallel workers via partitioning — without changing your domain code.

Events committed in concurrent transactions can be re-ordered relative to their commit timestamps — a transaction that started earlier may commit later. Without gap detection, the projection reads the visible event with the higher position, advances its cursor past the gap, and silently skips the event that committed later. Ecotone's GapAwarePosition records the gap and keeps advancing on the visible events without blocking concurrent writes; when the missing event becomes visible the projection applies it then — so concurrent-commit events are never silently dropped, and concurrent access is never blocked.

Yes — a projection can publish a new event the moment it applies a change (via EventStreamEmitter), and sagas, other projections, and event handlers react to it through the normal #[EventHandler]. That keeps dependent logic in the same flow instead of running a separate eventually-consistent process that polls the read model. Emission is automatically suppressed during a projection rebuild, so downstream consumers aren't flooded with historical duplicate events on backfill.

One #[Sensitive] attribute on an event field encrypts the value in the event store, on the wire over RabbitMQ / SQS / Redis / Kafka / DBAL outbox, and in your structured logs — because all serialization flows through one shared conversion pipeline. Crypto-shred a customer by deleting their key; their events become unreadable everywhere they live.

Be part of the change with Ecotone

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

Get started