Skip to main content
Private Beta - 12+ Generators Available

Nobody Likes Writing
Boilerplate Code

Generate production-ready Symfony code from simple YAML schemas. Entities, forms, APIs, and more β€” in seconds, not hours.

12+
Generators Ready
100%
Open Source
Q4 2025
Launch Date
The Problem

Symfony Development is Repetitive

You spend hours writing the same boilerplate code for every project. Entities, forms, controllers, validations... Sound familiar?

⏰

Time Consuming

Hours spent on repetitive tasks

πŸ”„

Repetitive Code

Same patterns, different projects

❌

Error Prone

Manual coding leads to mistakes

😀

Developer Frustration

Focus on business logic, not setup

Features

Everything You Need to Ship Faster

Embrex handles the repetitive work so you can focus on what makes your application unique.

Lightning Fast

Generate complete Symfony applications in seconds, not hours. One command, everything ready.

12+ Generators Included

Entities, repositories, forms, controllers, API resources, validation, services, security, and more.

Flexible Architecture

Support for standard MVC, hexagonal architecture, and DDD. Your project, your rules.

Safe Updates

Update your schema and regenerate code without losing customizations. Git-aware merging.

Symfony Best Practices

Generated code follows Symfony standards and community best practices out of the box.

Production Ready

Security, validation, error handling - all included. Deploy with confidence.

And Much More...

Validation Rules
API Platform Resources
Service Classes
Security Voters
Messenger Handlers
Twig Components
Sylius Resources & Grids
And many more to come...
Simple Process

From Schema to Application in 3 Steps

No complex configuration. No steep learning curve. Just describe what you want and let Embrex do the work.

1

Define Your Schema

Write a simple YAML file describing your entities and their relationships.

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)
      
  Category:
    properties:
      name: string(100)
      slug: string(100)
2

Run Embrex Build

Execute a single command to generate all your code instantly.

$ php bin/console embrex:build

βœ“ Generating entities...
βœ“ Creating repositories...
βœ“ Building forms...
βœ“ Setting up controllers...
3

Start Building

Your application is ready! Focus on business logic, not boilerplate.

Entities created
Forms ready
APIs configured

Real-World Example: E-commerce Platform

Your Schema (schema.yaml)

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)
      
  Category:
    properties:
      name: string(100)
      slug: string(100)
    relations:
      products: oneToMany(Product)
      
  Order:
    properties:
      orderNumber: string(50)
      totalAmount: decimal(10,2)
      status: string(20)
    relations:
      items: oneToMany(OrderItem)
      
forms:
  ProductType:
    entity: Product
    fields:
      sku: text
      name: text
      price: money
      category: entity
    
controllers:
  ProductController:
    actions:
      index: /products
      show: /products/{id}
      
api_resources:
  ProductResource:
    entity: Product
    operations: [Get, GetCollection, Post, Put, Delete]

Generated Files

src/Entity/Product.php βœ“ Created
src/Repository/ProductRepository.php βœ“ Created
src/Form/ProductType.php βœ“ Created
src/Controller/ProductController.php βœ“ Created
src/ApiResource/ProductResource.php βœ“ Created
+ 15 more files...
See The Difference

Hours of Work vs Seconds with Embrex

Compare the traditional approach with Embrex. See how much time and effort you can save.

Without Embrex (45+ min)
// src/Entity/Product.php
<?php

namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use DOctrine\DBAL\Types\Types;

#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'products')]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255, type: Types::TEXT)]
    #[Assert\NotBlank]
    #[Assert\Length(min: 3, max: 255)]
    private ?string $name = null;

    #[ORM\Column(type: Types::INTEGER]
    #[Assert\NotNull]
    #[Assert\PositiveOrZero]
    private ?int $price = null;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): static
    {
        $this->name = $name;
        return $this;
    }

    // ... more getters and setters ...
}

// src/Repository/ProductRepository.php
// src/Form/ProductType.php
// src/Controller/ProductController.php
// ... and many more files to write manually ...
With Embrex (30 sec)
# schema.yaml
entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)

forms:
  ProductType:
    entity: Product
    fields:
      sku: text
      name: text
      price: money
      category: entity

controllers:
  ProductController:
    actions:
      index: /products
      show: /products/{id}

validation:
  Product:
    properties:
      name:
        - NotBlank
        - Length: { min: 3, max: 255 }
      price:
        - NotNull
        - PositiveOrZero
$ Run command:
php bin/console embrex:build
Generated automatically:
Entity with all properties, getters/setters
Repository with custom query methods
Form type with validation
CRUD controller with all actions
Templates for views

That's 44.5 minutes saved on just one entity!

Imagine the time savings across your entire project with dozens of entities, forms, and controllers.

10+
Hours per project
100%
Consistency
0
Boilerplate bugs
Flexible Architecture

Build Your Way: Any Architecture

Whether you prefer traditional MVC or modern hexagonal architecture, Embrex adapts to your project's needs.

Standard Architecture

Traditional Symfony structure

Perfect for rapid development and smaller projects. Follow Symfony's conventions with entities in src/Entity/ and repositories in src/Repository/.

src/
β”œβ”€β”€ Entity/
β”‚ β”œβ”€β”€ Product.php
β”‚ └── Category.php
β”œβ”€β”€ Repository/
β”‚ β”œβ”€β”€ ProductRepository.php
β”‚ └── CategoryRepository.php
β”œβ”€β”€ Controller/
└── Form/
Quick to start
Follows Symfony conventions
Easy to understand

Hexagonal / DDD

Domain-driven design with contexts

Ideal for complex applications with multiple bounded contexts. Organize code by business domains with clear separation of concerns.

src/
β”œβ”€β”€ Catalog/
β”‚ β”œβ”€β”€ Domain/
β”‚ β”‚ β”œβ”€β”€ Entity/Product.php
β”‚ β”‚ └── ValueObject/Money.php
β”‚ β”œβ”€β”€ Application/
β”‚ └── Infrastructure/
└── Ordering/
β”œβ”€β”€ Domain/
└── Application/
Clear boundaries
Scalable for teams
Future-proof design

Standard Configuration

namespaces:
  entity: 'App\Entity'
  repository: 'App\Repository'
  form: 'App\Form'

paths:
  entity: 'src/Entity'
  repository: 'src/Repository'
  form: 'src/Form'

entities:
  Product:
    properties:
      sku: 'string(50)'
      name: 'string(255)'
      price: 'decimal(10,2)'
      stock: 'integer'
      isActive: 'boolean'
    relations:
      category: 'manyToOne(Category)'

  Category:
    properties:
      name: 'string(100)'
      slug: 'string(100)'
    relations:
      products: 'oneToMany(Product)'

Hexagonal Configuration

# Use the hexagonal convention
convention: hexagonal

contexts:
  Catalog:
    entities:
      Product:
        properties:
          sku: string(50)
          name: string(255)
          price: decimal(10,2)
        relations:
          category: manyToOne(Category)

      Category:
        properties:
          name: string(100)
          slug: string(100)
        relations:
          products: oneToMany(Product)

  User:
    entities:
      User:
        properties:
          email: string(180)
          username: string(100)

Start Simple, Scale When Needed

Begin with standard architecture and migrate to hexagonal as your project grows. Embrex supports gradual migration without rewriting everything.

Learn more - Join the waiting list
Ecosystem Ready

Works With Your Favorite Tools

Embrex integrates seamlessly with the Symfony ecosystem. Use the tools you love, enhanced by automatic code generation.

πŸ”₯

API Platform

Generate REST and GraphQL APIs automatically

OpenAPI documentation
Filters & pagination
JWT authentication
πŸ›οΈ

Sylius Stack

Admin UI and resource management

Resource system
State machines
Grids & filters
πŸ—„οΈ

Doctrine

Complete ORM integration with extensions

Migrations
Fixtures
Extensions
🎨

Symfony UX

Modern UI components ready to use

Live components
Turbo
Stimulus
πŸ“¬

Messenger

Async message handling and queues

Command bus
Event bus
Queue workers
πŸ”—

Webhooks

Real-time event notifications

HTTP callbacks
Event triggers
Retry logic

One Schema, Multiple Integrations

Define Once...

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      description: text
      isActive: boolean
    extensions:
      timestampable: ~
      
api_resources:
  ProductResource:
    entity: Product
    normalization_context:
      groups: [product:read]
    denormalization_context:
      groups: [product:write]
    filters:
      - search: [name, description]  
      - order: [name, price]
    
sylius_resources:
  Product:
    entity: Product
    driver: doctrine/orm
    
webhooks:
  stripe_payment:
    type: custom
    parser:
      request_matcher:
        path: /webhook/stripe
        methods: [POST]
        headers:
          stripe-signature: ~
    events:
      payment_intent.succeeded:
        properties:
          id: string
          amount: integer
          status: string

...Get Everything!

API Platform Auto-generated
  • β€’ REST endpoints on /api/products
  • β€’ GraphQL queries and mutations
  • β€’ OpenAPI documentation
Sylius Stack Auto-generated
  • β€’ Resource management
  • β€’ Grid with filters & sorting
  • β€’ State machine workflows
Webhooks Auto-generated
  • β€’ Event listener configuration
  • β€’ HTTP client configuration
  • β€’ Retry & error handling

Need More?

Create your own custom integrations with our extensible architecture. Additional integrations for Sylius, Sonata Admin, and more are available in our Enterprise offering.

Enterprise Solutions

Embrex for Teams

Professional services and advanced tooling for agencies, consultancies, startup studios, freelancers, and internal teams. Consulting available now, advanced features coming soon.

Consulting Services - Accelerate Today

Architecture Review

Audit your existing Symfony architecture and get recommendations for Embrex adoption

Custom Training

Tailored training sessions for your team on Embrex Bundle and Symfony best practices

Migration Support

Hands-on support to migrate your existing projects to use Embrex Bundle

Consulting Services

Available for hourly consulting or project-based engagements

Available Now

Embrex Builder

Visual interface for creating Embrex schemas. Open source version available, with advanced enterprise features planned.

  • Interactive entity designer
  • Multiple builders (Forms, API, Controllers...)
  • Export/Import YAML schemas
  • Real-time YAML generation
  • Team collaboration (roadmap)
  • Custom templates (roadmap)
Request a Demo

Embrex Builder Interface

Product { name: string, price: decimal }
Product Category
//
class Product extends Entity {...}

Ready to Transform Your Development?

Contact us to discuss your specific needs and discover how Embrex can accelerate your projects.

Private Beta

Join Happy Developers

We're currently in private beta. Join the waiting list to be among the first to transform your Symfony development workflow.

Ready for Launch

12+
Generators
5+
Beta Testers
100%
Open Source
2025
Launch Year

Join the Waiting List

Optional
Optional - helps us understand your needs

By signing up, you agree to receive emails about Embrex. Your data is secure and will never be shared.

Ready to 10x Your
Symfony Development?

Transform your Symfony development workflow with intelligent code generation.

Coming soon via Composer:

composer require --dev embrex/embrex-bundle
Lightning Fast
Generate in seconds
Production Ready
Best practices included
100% Customizable
Your code, your way