| description | Ecotone Enterprise features for scaling multi-tenant and multi-service PHP systems |
|---|
Ecotone Free gives you production-ready CQRS, Event Sourcing, and Workflows — message buses, aggregates, sagas, async messaging, retries, error handling, and full testing support.
Ecotone Enterprise is for when your system outgrows single-tenant, single-service, or needs advanced resilience and scalability.
| Capability | Free | Enterprise |
|---|---|---|
| CQRS (Commands, Queries, Events) | Yes | Yes |
| Event Sourcing & Projections | Yes | Yes |
| Sagas (Stateful Workflows) | Yes | Yes |
| Handler Chaining (Pipe & Filter) | Yes | Yes |
| Async Messaging (RabbitMQ, SQS, Redis) | Yes | Yes |
| Retries & Dead Letter | Yes | Yes |
| Outbox Pattern | Yes | Yes |
| Interceptors (Middlewares) | Yes | Yes |
| Testing Support | Yes | Yes |
| Multi-Tenancy | Yes | Yes |
| OpenTelemetry | Yes | Yes |
| Orchestrators | Yes | |
| Distributed Bus with Service Map | Yes | |
| Dynamic Message Channels | Yes | |
| Partitioned Projections | Yes | |
| Blue-Green Deployments | Yes | |
| Kafka Integration | Yes | |
| Command Bus Instant Retries | Yes | |
| Gateway-Level Deduplication | Yes |
Ecotone comes with two plans:
- Ecotone Free comes with Apache License Version 2.0. It provides everything you need to build message-driven systems in PHP -- CQRS, aggregates, event sourcing, sagas, async messaging, interceptors, and full testing support. This covers all features not marked as Enterprise.
- Ecotone Enterprise adds production-grade capabilities for teams whose systems have grown into multi-tenant, multi-service, or high-throughput environments. It brings advanced workflow orchestration, cross-service communication, resilient command handling, and resource optimization.
Every Enterprise licence directly funds continued development of Ecotone's open-source core. When Enterprise succeeds, the entire ecosystem benefits.
{% hint style="success" %}
Each Enterprise feature is marked with hint on the documentation page. Enterprise features can only be run with licence key.
To evaluate Enterprise features, email us at "support@simplycodedsoftware.com" to receive trial key. Production license keys are available at https://ecotone.tech.
{% endhint %}
You don't need Enterprise on day one. These are the growth signals that tell you it's time:
A noisy tenant's queue backlog shouldn't affect others. Per-tenant scaling shouldn't mean building custom routing infrastructure.
- Dynamic Message Channels -- Route messages per-tenant at runtime using header-based or round-robin strategies. Declare the routing once, Ecotone manages the rest. Add tenants by updating the mapping -- no handler code changes.
Business stakeholders ask "what are the steps in this process?" and the answer requires reading multiple files. Adding or reordering steps touches code in many places.
- Orchestrators -- Define workflow sequences declaratively in one place. Each step is independently testable and reusable. Dynamic step lists adapt to input data without touching step code.
Building custom inter-service messaging wiring for each service pair has become unsustainable. Different services use different brokers and you need them to communicate.
- Distributed Bus with Service Map -- Cross-service messaging that supports multiple brokers (RabbitMQ, SQS, Redis, Kafka) in a single topology. Swap transports without changing application code.
A single global projection can't keep up with event volume. Rebuilding wipes the read model for 30 minutes. Changing projection schema means downtime for users.
- Partitioned Projections -- One partition per aggregate with independent position tracking. Failures isolate to a single aggregate instead of blocking everything. Indexed event loading skips irrelevant events for dramatically faster processing. Works with both sync and async execution.
- Async Backfill & Rebuild -- Push backfill and rebuild to asynchronous background workers with
asyncChannelName. Combined with partitioned projections, the work is split into batches that multiple workers process in parallel — throughput scales linearly with worker count. A backfill that takes 2 hours with 1 worker takes 12 minutes with 10. - Blue-Green Deployments -- Deploy a new projection version alongside the old one. The new version catches up from history while the old one serves traffic. Switch when ready, delete the old one. Zero downtime.
- Streaming Projections -- Consume events directly from Kafka or RabbitMQ Streams instead of the database event store. For cross-system integration and external event sources.
- High-Performance Flush State -- Accumulate state in memory across a batch of events and persist once at flush. Process 1000 events with zero database writes, then one bulk insert. Dramatically faster rebuilds.
RabbitMQ throughput is becoming a bottleneck, or multiple services need to consume the same event stream independently.
- Kafka Integration -- Native Kafka support with the same attribute-driven programming model. No separate producer/consumer boilerplate.
- RabbitMQ Streaming Channel -- Kafka-like persistent event streaming on existing RabbitMQ infrastructure. Multiple independent consumers with position tracking.
Transient failures cause unnecessary handler failures. Duplicate commands from user retries or webhooks lead to double-processing. Exception handling is scattered across handlers.
- Command Bus Instant Retries -- Recover from transient failures (deadlocks, network blips) with a single
#[InstantRetry]attribute. No manual retry loops. - Command Bus Error Channel -- Route failed synchronous commands to dedicated error handling with
#[ErrorChannel]. Replace scattered try/catch blocks with centralized error routing. - Gateway-Level Deduplication -- Prevent duplicate command processing at the bus level. Every handler behind that bus is automatically protected.
Repository injection boilerplate obscures business logic. Every handler follows the same fetch-modify-save pattern. Making the entire bus async requires annotating every handler individually.
- Instant Aggregate Fetch -- Aggregates arrive in your handler automatically via
#[Fetch]. No repository injection, just business logic. - Event Sourcing Handlers with Metadata -- Pass metadata to
#[EventSourcingHandler]for context-aware aggregate reconstruction without polluting event payloads. - Asynchronous Message Buses -- Make an entire command or event bus async with a single configuration change, instead of annotating every handler.
Database transactions are globally enabled for your message channel, but some handlers only call a 3rd party API or send emails — wrapping them in a transaction wastes connections and holds locks unnecessarily.
- Async Endpoint Annotations -- Pass
endpointAnnotationson#[Asynchronous]to selectively disable transactions, message collectors, or inject custom configuration for specific handlers while keeping global defaults for the rest of the channel.
Custom consumer scripts need manual connection handling, reconnection logic, and shutdown management.
- Rabbit Consumer -- Set up RabbitMQ consumption with a single attribute. Built-in reconnection, graceful shutdown, and health checks out of the box.