Two paths to DDD. One fundamental difference.
Ecotone gives you a runtime framework with attributes and a message bus. Jardis generates the architecture code and gives you full control over every file. Both solve DDD in PHP. The approach could not be more different.
Frameworks abstract. But abstraction has a cost.
Runtime frameworks for DDD are powerful. But they bind you to their abstraction, even when your project outgrows it.
Your domain code belongs to the framework
Ecotone uses PHP attributes to declare commands, events, and aggregates. Your business logic is laced with framework annotations. Want to remove Ecotone? You refactor every class. Domain code becomes a framework dependency.
What happens behind the attributes?
Attribute-based configuration is compact, but the infrastructure happens invisibly. Routing, handler resolution, serialization: the framework decides. When behavior does not match your expectations, you debug foreign framework code.
Messaging architecture from day one
Ecotone uses message channels as its communication model. That is powerful for event-driven systems, but forces an architecture decision before you know whether you need it. Not every domain needs asynchronous messaging from the start.
Code you own. Not a framework you depend on.
Jardis generates PHP code you can read, modify, and own. No runtime framework, no hidden abstractions, no attributes in your domain.
Generated code without framework dependency
The Jardis builder generates entities, aggregates, commands, queries, and domain events as pure PHP code. No framework attributes, no runtime magic. Every class is readable, testable, and yours. You can remove Jardis tomorrow and the code keeps working.
Hexagonal architecture at the filesystem level
Ecotone steers architecture through attribute conventions at runtime. Jardis enforces hexagonal architecture physically through package structures. Bounded contexts are standalone PHP packages. Layer boundaries are directory structures, not annotations. Violations are technically impossible, not just discouraged.
No messaging overhead for simple domains
Not every bounded context needs message channels and event sourcing. Jardis generates the architecture you define: CQRS for complex domains, straightforward repository pipelines for simple ones. You decide per domain, not the framework.
See what three files turn into.
Three definition files in, a complete bounded context out. Browse the generated code.
# Database Schema — Sales Bounded Context
# This file defines the persistent storage structure.
schema:
domain: ECommerce
boundedContext: Sales
tables:
order:
columns:
id:
type: integer
primary: true
autoIncrement: true
public_id:
type: uuid7
unique: true
customer_email:
type: string
length: 255
status:
type: string
length: 32
default: "draft"
total_amount:
type: integer
currency:
type: string
length: 3
default: "EUR"
created_at:
type: datetime
updated_at:
type: datetime
nullable: true
order_item:
columns:
id:
type: integer
primary: true
autoIncrement: true
order_id:
type: integer
foreignKey:
table: order
column: id
onDelete: cascade
product_name:
type: string
length: 255
sku:
type: string
length: 64
quantity:
type: integer
unit_price:
type: integer
line_total:
type: integer
Why teams choose generated code over a runtime framework.
Not because Ecotone is bad. But because code ownership gives more control long-term than framework abstraction.
Every line is your code
No debugging framework internals, no hidden conventions. What the builder generates lives as PHP files in your repository. New developers read code, not framework docs.
Framework-agnostic from the domain layer
Generated code works with Laravel, Symfony, or without a framework. Ecotone ties you to its messaging model. Jardis generates code you embed in any PHP environment.
No framework upgrade risk in the domain
Your domain logic has no Ecotone dependency, no attributes that break on major updates. Generated code is stable PHP, independent of framework release cycles.
Ready for DDD in PHP without runtime dependency?
Join the WaitlistStructure costs less than chaos.
Try Jardis 7 Days Free
Point Jardis at your real domain. Discovery, structure, and your first platform build.
Join WaitlistThe complete DDD architecture with all classes and contracts. Your team ships features, not infrastructure.
Join WaitlistThe complete business logic with handlers, validation, and pipelines. What used to be a sprint is now a build.
Join WaitlistMore than 20 Platform Builds per month?
Let's talkBe there when Jardis launches.
Sign up. You'll get access as soon as we go live. Including a free trial.
Curious how Jardis works?
Discover JardisFrequently Asked Questions
Answers to the most important questions comparing Jardis and Ecotone.
No. Ecotone is a well-designed PHP framework for message-driven architecture with CQRS and Event Sourcing. The difference is in the approach: Ecotone abstracts infrastructure at runtime, Jardis generates it as PHP code you own. Teams that prefer full code ownership and physical architecture boundaries are better served by Jardis.