Pure PHP. Real architecture. No framework in between.
You want DDD without framework dependencies. Good instinct. But building everything yourself means weeks spent on infrastructure that delivers no business value. Jardis generates framework-agnostic PHP code that does exactly what you want.
Framework-free does not mean effort-free.
The desire for pure PHP is valid. But without tooling, DDD becomes a full-time job.
Every layer from scratch
No framework means no DI container, no event dispatcher, no routing. You build everything yourself. Repository interfaces, command bus, event handling. Before the first domain rule is written, you have spent three months on infrastructure.
Knowledge lives in individual heads
Without a framework, there are no community conventions. Every team invents its own patterns for repository abstraction, event publishing, and layer separation. New developers face a custom architecture that is documented nowhere.
Consistency dies under the first deadline
Aggregate root patterns, value object validation, event naming: under sprint pressure, every developer writes it differently. Without enforced structure, the architecture drifts further apart with every merge request.
Framework-agnostic code that does not need to be built by hand.
Jardis generates pure PHP. No Laravel dependency, no Symfony dependency, no framework coupling. But with the consistency that manual architecture cannot deliver.
Generated domain code with zero framework imports
The Jardis builder generates Bounded Contexts as standalone PHP packages. No dependency on Laravel, Symfony, or any other framework. Domain Entities, Value Objects, Aggregates, Commands, Queries, and Events: pure PHP. Integrate the code into any framework or use it standalone.
Hexagonal architecture at the filesystem level
Manual DDD without a framework fails at enforcement. Jardis enforces layer boundaries physically: Domain, Application, and Infrastructure are separate directories with clear dependency rules. An import from the wrong layer is structurally impossible, not just discouraged.
CQRS, Events, and Repository Pipeline from minute one
Instead of spending months building a command bus, event dispatcher, and repository abstractions, the builder generates the complete pipeline in PHP: Commands, Command Handlers, Queries, Query Handlers, Domain Events, and the 5-stage Repository Pipeline. All framework-agnostic, all immediately ready.
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 framework-agnostic DDD works better with Jardis.
Not because pure PHP is wrong. But because infrastructure work keeps you from writing domain logic.
No framework import in your domain
The generated code has zero external dependencies. Your domain logic stays portable. Symfony today, Laravel tomorrow, something custom next year: the domain stays identical.
Same structure in every Bounded Context
No individual architectures per domain. Every Bounded Context follows the same package structure, the same naming conventions, the same layer separation. Predictable for every developer on the team.
Structure that holds, even under pressure
Manual architecture erodes under time pressure. The builder enforces hexagonal architecture at the filesystem level. Layer boundaries are physical, not documented. No shortcuts possible.
DDD in pure PHP, without building it all yourself?
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 about DDD without a framework using Jardis.
Yes. Jardis generates pure PHP with no dependencies on Laravel, Symfony, or any other framework. Domain Entities, Value Objects, Commands, Queries, and Events are pure PHP classes. You can integrate them into any framework or use them standalone.