🚀 From Zero to Hero with Sylius: Inside the Practical Essentials Workshop

on May 24, 2025

If you're new to Sylius or looking to solidify your foundations, Gracjan Józefczyk, BitBag Developer & Sylius Key Contributor. It was a workshop at Sylius Days 2025 was a masterclass in eCommerce architecture. 💡

Mastering Sylius Fundamentals: From Resource Configuration to Grids

In a hands-on Sylius workshop led by key contributor and Sylius Academy creator Grazian, experienced Symfony developers explored the foundation of Sylius through live coding, architectural insights, and real-world implementation strategies. This post distills the core technical knowledge from the session—focused on understanding Sylius' dual identity as a platform and a framework, the power of the ResourceBundle and GridBundle, and effective customization approaches.

Problem Context:

Sylius is a Symfony-based eCommerce solution that aims to be both developer-friendly and enterprise-ready. However, getting started or extending it (e.g., creating custom resources or interfaces) often feels daunting due to its opinionated architecture and dependency on its own bundles. Developers entering a Sylius project must first understand how the core entities, services, and configurations interplay to avoid friction later.

Solution Breakdown:

Understanding Sylius as a Framework and Platform

Sylius provides a bootstrap-based shop frontend, an admin panel, and a complete API out of the box. It combines the flexibility of a Symfony framework with the plug-and-play capabilities of an eCommerce platform.

Admin Panel: Uses Symfony Security firewalls to distinguish between admin and customer logins.

API: Built with API Platform. Endpoints are exposed for both shop and admin, with clear separation via /shop and /admin prefixes.

Resource Configuration with ResourceBundle

The SyliusResourceBundle abstracts away common CRUD operations by leveraging configuration-based entity declarations. To define a new resource:

sylius_resource:
    resources:
        app.brand:
            driver: doctrine/orm
            classes:
                model: App\Entity\Brand

This single block enables:

Controller instantiation (via ResourceController)
Factory, FormType, and Repository autowiring
Service autoconfiguration and routing

Bonus: Use debug:sylius:resource to inspect resource bindings.

Exposing Routes with Symfony Routing Config

Once declared, resource routes are exposed via:

sylius_admin_brand:
    resource: "sylius.resource"
    type: sylius.resource
    section: admin
    alias: app.brand
    templates: SyliusAdminBundle:Crud
    redirect: update
    grid: sylius_admin_brand

Data Listing with GridBundle

SyliusGridBundle enables admin-side grids for data visualization and interaction (filters, actions, bulk operations).

sylius_grid:
    grids:
        sylius_admin_brand:
            driver:
                name: doctrine/orm
                options:
                    class: App\Entity\Brand
            fields:
                name:
                    type: string
                    label: sylius.ui.name
            filters:
                name:
                    type: string

Grids integrate seamlessly with ResourceBundle. They support:

Column filters
Inline and bulk actions
Easy frontend rendering via Bootstrap-based templates

Extensibility and Community Practices

Advanced use cases showcased during the workshop:

Migrating from Sylius 1.14 to Sylius 2 (major changes in Grid rendering, ResourceBundle internals)
Using new PHP attribute-based resource declarations (#[AsResource]) to remove YAML verbosity
Replacing Winzou state machine with Symfony Workflow for order transitions
Integration strategies for CMS, PIM, or search backends (Elasticsearch)

A key strength of Sylius is its active community, maintaining open-source plugins (Stripe, Admin UI, etc.) and contributing back through GitHub and Slack support.

Result/Impact: Participants left with a production-ready Sylius setup, configured Docker environment, and practical knowledge to:

Extend Sylius with custom entities:

Use declarative configuration for rapid CRUD
Customize admin grids
Migrate to newer Sylius versions
This approach boosts maintainability, developer onboarding, and speeds up initial development cycles.

Key Takeaways:

SyliusResourceBundle eliminates boilerplate for CRUD.
SyliusGridBundle provides production-grade admin listings with minimal config.
Symfony integration is first-class, enabling smooth DX.
Community contributions and practices are critical for scaling Sylius.
Use YAML or PHP Attributes based on your project scale and team conventions.

🔧 Mastering Sylius Customizations and Plugins — Advanced Developer Insights

During the advanced Sylius workshop, developers dived deep into two critical aspects of customizing enterprise-level e-commerce: tailoring the business logic via entity, form, and template overrides, and building modular, reusable plugins that remain maintainable and compatible across Sylius versions.

🧩 The Challenge

Modern e-commerce implementations often require tailored logic (e.g., product configurators, vendor-specific data, layered promotions). The default Sylius setup is flexible, but not always turn-key for these advanced needs.

Key developer goals include:

Extending entities without breaking inheritance or Doctrine mappings.
Injecting new fields into Symfony forms.
Overriding templates in a future-proof way.
Developing reusable plugins with test environments and version compatibility.

🛠️ Technical Implementation

Extending Entities and Forms

Example: Adding a `brand` relation to `Product`

// src/Entity/Product.php
class Product extends BaseProduct
{
    #[ORM\ManyToOne(targetEntity: Brand::class)]
    private ?Brand $brand = null;

    public function getBrand(): ?Brand { return $this->brand; }
    public function setBrand(?Brand $brand): void { $this->brand = $brand; }
}

Inject the field in the admin form using a Form Type Extension:

// src/Form/Extension/ProductTypeExtension.php
class ProductTypeExtension extends AbstractTypeExtension
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder->add('brand', EntityType::class, [
            'class' => Brand::class,
            'choice_label' => 'name',
            'required' => false,
        ]);
    }

    public static function getExtendedTypes(): iterable
    {
        return [ProductType::class];
    }
}

Template Overrides with Twig Hooks

Instead of copying entire templates, you can inject custom logic using Twig Hooks, introduced in Sylius 1.11+.

{ % hook 'sylius.admin.product.form.tab' % }
    { { render(controller('App\\Controller\\BrandController::index')) } }
{ % endhook % }

You can inspect hook names and usage via the Symfony Profiler. Each hook accepts:

A priority (for order)
Parameters (passed to the template)
Optional pre/post hook zones

Building Robust Plugins

Plugin Skeleton

Sylius plugins follow a Symfony bundle structure:

src/
  MyPlugin/
    Controller/
    Entity/
    Repository/
    DependencyInjection/
    MyPlugin.php

They register configuration, routes, and services via dedicated manifests. Common use cases include:

Payment integrations (Stripe, Mollie, PayPal)
SEO features (sitemaps, structured data)
Import/Export functionality
Custom promotions, attributes, or checkout logic

Shared Test Application (New Approach)

Historically, each plugin had to ship with a full Sylius test app — creating maintenance nightmares across multiple versions.

Now, the community provides a shared test app package:

composer require --dev sylius/plugin-test-application

This allows per-version CI matrix testing with automatic config patching based on Sylius/Symfony versions.

sylius:
    version: ["1.11", "1.12", "1.13", "1.14", "2.0"]
    symfony: ["5.4", "6.4"]

No more Kernel.php hacks — this makes plugin dev faster and far more maintainable.

📈 Outcome and Benefits

Extensibility: Business-specific needs are encapsulated cleanly with zero coupling to Sylius core.
Testability: Plugins run isolated with full CI and test apps.
Compatibility: Supports multiple Sylius/Symfony versions easily.
Developer Experience (DX): Tools like Twig Hooks and sylius:make:resource speed up implementation dramatically.

✅ Key Takeaways for Developers

✅ Use Doctrine inheritance and FormTypeExtension to extend entities and forms cleanly.
✅ Leverage Twig Hooks to inject UI logic without overriding full templates.
✅ Structure your plugins like Symfony bundles and follow best practices (non-final repositories, isolated services).
✅ Use the new test application tool to make your plugins compatible with multiple versions of Sylius and Symfony.
✅ Extract reusable logic into plugins (payment, import/export, Elasticsearch, wishlists…) to scale across projects.

✅ Why This Matters

This workshop wasn't just theoretical — it was built for action. If you're building scalable, customizable, and developer-friendly eCommerce solutions, mastering Sylius is a no-brainer. And Gracjan’s guidance made that journey 10x faster. ⚡

SyliusCon 2025

SyliusCon 2024 was a pivotal moment for the Sylius community, and the excitement is already building for SyliusCon 2025, promising even deeper insights, technical showcases, and community-driven innovation in the evolving e-commerce landscape.

Ressources

Sylius components

RessourceBundle : https://github.com/Sylius/SyliusResourceBundle
GridBundle : https://github.com/Sylius/SyliusGridBundle
Twig hooks : https://afup.org/talks/4929-creer-des-interfaces-d-administration-rapidement-avec-symfony-ux-et-sylius
SyliusRecipes : https://github.com/Sylius/SyliusRecipes
SyliusStandard : https://github.com/Sylius/Sylius-Standard
SyliusDemo : https://github.com/Sylius/SyliusDemo

Plugins

Stripe plugin : https://github.com/FLUX-SE/SyliusPayumStripePlugin
SyliusElasticsearchPlugin : https://github.com/BitBagCommerce/SyliusElasticsearchPlugin
SEO plugin
import export (Friend of Sylius) https://github.com/FriendsOfSylius/SyliusImportExportPlugin
whishlist
GDPR plugin (synolia)
Gift card
Invoices

💡 Bonus for Creators & Builders

Want to automate your own processes like thumbnail creation, video publishing, or workflow management?

👉 I offer 30-minute free coaching sessions to help creators like you move faster. Let’s simplify your stack, together. 📞 Book your free session here

🚀 From Zero to Hero with Sylius: Inside the Practical Essentials Workshop

Mastering Sylius Fundamentals: From Resource Configuration to Grids

Problem Context:

Solution Breakdown:

Extensibility and Community Practices

🔧 Mastering Sylius Customizations and Plugins — Advanced Developer Insights

🧩 The Challenge

🛠️ Technical Implementation

Extending Entities and Forms

Example: Adding a `brand` relation to `Product`

Inject the field in the admin form using a Form Type Extension:

Template Overrides with Twig Hooks

Building Robust Plugins

Plugin Skeleton

Shared Test Application (New Approach)

📈 Outcome and Benefits

✅ Key Takeaways for Developers

✅ Why This Matters

SyliusCon 2025

Ressources

💡 Bonus for Creators & Builders

Site

Network

Social

🚀 From Zero to Hero with Sylius: Inside the Practical Essentials Workshop

Mastering Sylius Fundamentals: From Resource Configuration to Grids

Problem Context:

Solution Breakdown:

Extensibility and Community Practices

🔧 Mastering Sylius Customizations and Plugins — Advanced Developer Insights

🧩 The Challenge

🛠️ Technical Implementation

Extending Entities and Forms

Example: Adding a brand relation to Product

Inject the field in the admin form using a Form Type Extension:

Template Overrides with Twig Hooks

Building Robust Plugins

Plugin Skeleton

Shared Test Application (New Approach)

📈 Outcome and Benefits

✅ Key Takeaways for Developers

✅ Why This Matters

SyliusCon 2025

Ressources

💡 Bonus for Creators & Builders

Site

Network

Social

Example: Adding a `brand` relation to `Product`