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.

Durable Workflows in PHP

Sagas, orchestrators, chained workflows, outbox, and #[Delayed] saga timeouts — on the database and broker you already operate. No separate workflow service. Plain PHP classes with attributes.

Durable Execution — 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 durable workflows

Durable Workflows in Plain PHP

Crash-resistant multi-step processes on your existing database and broker. Sagas, orchestrators, chained workflows, outbox, and #[Delayed] timeouts — plain PHP attributes, no separate workflow service, no replay-deterministic DSL.

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.

Resilience Defaults

Transactional outbox, DBAL dead-letter queue with replay, retries with exponential backoff, deduplication, OpenTelemetry on every handler — default behaviour, not assembly required.

Per-handler Failure Isolation

A copy of the message is dispatched to every handler. Each retries independently, fails independently — no shared envelope, no sibling re-runs. One failing subscriber doesn't abort the others.

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.

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.

Temporal PHP SDK

A Temporal cluster, RoadRunner, gRPC, and a deterministic-replay DSL.

Requires a running Temporal cluster (Go-based server) plus RoadRunner as the PHP worker runtime and `ext-grpc` on the client.
Workflow code constrained to deterministic replay — no `Date::now`, no `random_int`, no direct I/O outside Activities; the failure mode is the non-determinism error.
Long-running flows accumulate `getVersion` / `patched` branches that survive until the last in-flight execution finishes.
Task queues are internal to the cluster — cannot reuse your existing RabbitMQ / Kafka / SQS without writing bridging Activities.
Durability primitives are best-in-class, at the cost of operating the cluster.

Durable Workflow (formerly Laravel Workflow)

Laravel-only; workflow-only; no first-class sagas as process managers.

Workflow classes extend the `Workflow` base, activities extend `Activity`.
Generator DSL (`yield activity(MyActivity::class, $arg)`) drives the durability.
Durability is bounded by Laravel queue guarantees, not a dedicated cluster.
No first-class identifier-mapped saga that lives across events arriving over time.
No distributed bus, no cross-broker — single Laravel app oriented.

Symfony Messenger alone

Retry is per-transport, not per-handler. No saga.

Retry strategy is configured per-transport, so two handlers on the same message share the retry envelope.
No saga base class or process-manager primitive (Symfony Workflow is a state-machine library, not a durable workflow engine).
No `#[Delayed]`-style timeout attribute on event handlers — long-running waits become custom scheduler code.

Laravel Queues / Horizon

A job runner. No saga state, no workflow durability primitives.

Jobs implement `ShouldQueue` + `Queueable` trait; one job = one handler.
No saga state machine that lives across events arriving over time.
Durability of multi-step processes is bounded by Laravel queue guarantees; no built-in identifier-mapped coordinator.
Horizon is Redis-only.

Ecotone

Workflows that grow from one saga to a distributed orchestration topology.

Start with a `#[Saga]` for the first long-running process — plain PHP, no separate workflow runtime to deploy.
Layer `#[Orchestrator]` for declarative multi-step workflows with routing-slip semantics as complexity grows.
Use chained `#[InternalHandler]` for stateless flows where the message itself carries the state.
Saga timeouts are `#[Delayed]` attributes — no cron, no separate timer service.
The same retry / DLQ / idempotency / outbox primitives that protect your in-process messages apply across the saga's lifetime, on the brokers you already operate.

Read the Durable Workflows guide

Frequently asked questions

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

No. Ecotone delivers durable execution on the database and broker you already operate. Sagas persist state per identifier, chained workflows survive crashes through the outbox plus async channel, saga timeouts use a #[Delayed] attribute, and Orchestrators give declarative multi-step workflows. No separate cluster, no RoadRunner / ext-grpc, no replay-deterministic DSL. If your team already runs Temporal, Ecotone composes around it for CQRS, projections, distributed messaging, and sagas that aren't full workflows.

Saga timeouts are a single #[Delayed] attribute on an event handler. The handler fires after the specified TimeSpan, exact DateTime, or expression — no cron, no separate timer service. The broker's underlying delayed-message primitive (RabbitMQ delayed exchange, SQS message timer, Redis sorted-set) does the waiting; the consistent attribute model hides the broker specifics from your code.

The broker redelivers the message. The saga reloads from the database on the next event arrival bearing its identifier. The handler runs again — built-in deduplication tolerates duplicate delivery, and the outbox ensures the business write and the message commit together. The same recovery semantics Temporal gives by replaying Event History, Ecotone gives by redelivering the message — and the message is in your own broker, in your own database, in your own schema.

Yes. Chained handlers via outputChannelName give stateless durable workflows where the message itself carries the state. When the async channel runs through an outbox (CombinedMessageChannel), each step is committed atomically with its business write before the message advances. If a worker crashes, the broker redelivers; the work resumes on the next consumer. No saga record needed.

Be part of the change with Ecotone

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

Get started