The Contract Exists. Before Any Code Is Written.
Most teams write the code first and the docs second. Jardis reverses that: API contracts in OpenAPI and gRPC are generated alongside domain code, so frontend and backend can start in parallel.
API Docs That Always Lag Behind.
The code is done, the API is running. Now the docs are missing. By the time they are accurate, the interface has changed twice.
Frontend waits on backend decisions
The backend developer decides on the fly how an endpoint should look. The frontend team is blocked. Hours of coordination calls do not replace a defined contract.
API docs are always out of date
Swagger files are maintained by hand. After three sprints, the documentation no longer matches reality. Everyone knows it, no one has time to catch up.
Interfaces are designed after the fact
API design is a byproduct of implementation. Contract errors surface only when frontend and backend finally meet. By then, rework is expensive.
How Jardis Implements API-First Architecture.
Jardis generates OpenAPI and gRPC contracts as part of the domain code. Not afterward, not separately. Simultaneously.
Domain schema as the single source of truth
You define your database schema and aggregate structure. The builder understands which operations each bounded context should expose. The domain model is the single source of truth for both code and contract.
Contracts emerge with the domain code
Jardis generates OpenAPI specs and gRPC service definitions alongside entities, commands, queries, and domain events. The contract describes exactly what the builder implements. No gap between specification and reality.
Frontend and backend start at the same time
The contract is ready. The frontend team builds against the OpenAPI spec while the backend team fills the generated structures with business logic. No blockers, no surprises when the two sides finally meet.
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 Adopt API-First with Jardis.
Because contracts should not be a documentation task. They should be a design principle.
API Design Before Implementation
OpenAPI and gRPC contracts are generated in the same builder run as the domain code. The interface is defined before the first line of business logic is written.
Docs That Cannot Go Stale
The contract is not a separate document. It is generated output from the same schema as the PHP code. When the model changes, contract and code change together.
Frontend and Backend Decoupled
Frontend teams mock against the OpenAPI spec. Backend teams fill the generated structures with business logic. Both work simultaneously, without waiting on each other.
Ready to treat API design as a first-class principle?
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 about API-First Architecture with Jardis.
The builder generates OpenAPI 3.x specs and gRPC service definitions (.proto files) for each bounded context. Both are created alongside the PHP domain code in a single builder run. No manual follow-up required.