✨ SyliusCon 2025: The Sylius ecosystem reaches full maturity

on October 20, 2025

SyliusCon 2025 confirmed that the Sylius ecosystem is now a major player in the open source e-commerce landscape. Built on the solid foundation of Symfony, Sylius continues its technical growth, while opening up to new horizons: cloud scalability, a modernized developer experience, and the growing integration of artificial intelligence.

This year's packed program reveals a professional setting, focused on production and efficiency. Far from hype, the conferences highlighted concrete topics: migration, performance, automation, and pragmatic AI.

Sylius 2024–2025: Community, Product, and B2B Focus, by Mikołaj Król

Community & Ecosystem

  • Record year for meetups (even outside Europe) and conference participation: the strategy is clear—strengthening IRL ties. * 15 new partners join the ecosystem (with a leading partner in France). * Arrival (return) of a CTO, Simon, a contributor from the very beginning. * Hats off to the key contributors and volunteers who maintain the open-source heart.

Product rhythm & versions

  • 30 releases published over the year (security + features). * Sylius 1.x: last year in 2025, end of support in 2026 → recommended course on Sylius 2 (support tools planned).

Doc-First & official extensions

  • Documentation-first shift: write the manual before the feature to accelerate adoption and quality. * Official CMS (simplified UX dev & editor) and Wishlist now maintained Sylius plugins. * MCP standard (commerce agent): first concrete steps to buy via agent in Sylius — strategic topic to follow. * Overhaul of the plugin process: new skeleton, smoother pipeline, dedicated test-app to verify plugins on several versions (Sylius 1 & 2).

Front & DX

  • Boilerplate React/PWA connected to the Sylius API to shorten headless projects. * Store Wizard: generate a demo/POC in minutes (data + skin), boosted with AI — useful for pre-sales. * New modules:

    • Request for Quotation (RFQ) for B2B; * Made-to-Order / Web-to-Print for custom/made-to-order products.

B2B Focus: “Elasto”

  • Launch of a B2B accelerator (UX review, advanced pricing, integrations, large catalogs tested ~600k SKUs). * Public demo available + live demo on the booth.

Roadmap 2026

  • Marketplaces: dedicated accelerator (modern features, polished DX). * B2C Fashion pack: express start for fashion cases. * AI for devs: libraries + contexts to accelerate creations, migrations and maintenance. * Installation of plugins/themes from the admin, and redesign of the Sylius Store to better monetize themes/plugins (call to creators).

Things to remember for Darkwood

  • If you are starting or migrating: anticipate Sylius 2; use the test-app and accelerators (B2B/coming Marketplace & Fashion). * For pre-sales: Store Wizard allows you to create a convincing POC in a few minutes. * On the offer side: think RFQ and Made-to-Order if your journeys require it. * If you are editing extensions: window of opportunity with the installation admin and the redesign of the Store.

Key message: Sylius consolidates its base (docs, official plugins, DX), accelerates B2B with a showcase product (Elasto) and prepares 2026 around Marketplaces, B2C packs, IA dev and distribution of extensions from the admin.

From controlled maintenance to cloud scale

Mathias Arlaud's talk on deprecation management set the tone: the Symfony/Sylius pairing is reaching maturity. The time has come to stop racing for new versions and instead focus on rationally planning upgrades. Deprecations are becoming roadmap milestones, not roadblocks.

The same logic applies to performance. Erwin Hofman demonstrated how Chrome DevTools, enhanced with a built-in AI assistant, now simplifies debugging Core Web Vitals. Performance is becoming a business indicator in its own right.

And when Gracjan Józefczyk talks about Sylius's scalability in the cloud, the message is clear: the era of cloud-native e-commerce is fully open. ECS containers, Aurora database, S3 + CloudFront, SQS: Sylius proves its ability to handle massive loads, while remaining an open source framework. FrankenPHP plays a key role, modernizing the PHP deployment and execution chain.

Sylius can handle massive peaks (e.g., thousands of orders/hour or more) provided scalability is treated as a discipline: read/write database, containerized execution, CDN for heavy assets, and observability + fault tolerance. The “video game launch” use case serves as a stress test (AAA volume).

Context & issues

Typical customer question: “Can Sylius handle 6,000 orders/hour?”

Mental benchmark via the gaming industry (Elden Ring, Zelda, Cyberpunk, etc.): AAA releases create global peaks (millions of sales in a few days).

Conclusion: this level of load exists, we must prepare for it by design.

Recommended architecture (AWS as an example)

Database (Aurora/RDS)

Simple vertical scaling (RAM/CPU/storage) + read replicas in horizontal scaling.

Pattern read/write split (Doctrine/Symfony): write operations on the primary, massive reads on the replicas (indexing, search, analytics).

Automatic failover: in the event of a primary failure, a replica takes over (minimizes the incident instead of a costly snapshot restore).

Containerized Sylius App

ECS (or K8s) deployment with Auto Scaling: x instances at peak times, ↓ at night.

Separation of roles: HTTP containers vs workers (Messenger/cron).

Blue/green/canary: routing a percentage of traffic to V2; instant rollback via the load balancer.

Content Distribution & Latency

S3 + CloudFront for assets/heavy downloads (e.g. 100+ GB games) → traffic deported from the application server, edge cache close to customers (Sydney, NY, etc.).

Image management via Flysystem / LiipImagine + S3/CloudFront adapters (config change, no massive refactor).

Security & Network

App & DB in private subnets; only ALB/CloudFront exposed publicly.

Infrastructure as Code

Terraform/CloudFormation in Git: PR, review, traceability; everyone understands and can develop the infrastructure (no “wizard admin”).

SLA and cost of failure

99% availability = ~2 days 15 hours 36 minutes of downtime/year → losses on order peaks.

The cloud costs money, but it costs less than downtime at the wrong time.

Code-side implementation (Symfony/Sylius)

Multiple connections doctrine (primary/replicas) + “read-only” hints.

Images/FS: FilesystemInterface (Flysystem) → switch S3/CloudFront without changing the business code.

Sylius Docker-ready (docker-compose), transposable to production (ECS/K8s).

Key message

Sylius "flies" very well in the cloud if you decouple read/write, autoscale the app, and outsource the static/heavy work to the CDN. The bottleneck is not Sylius itself, but the architecture you give it.

Bonus Resource

Gracjan is launching a free course “Can Swans Fly?”: Deploying Sylius on AWS with Terraform (blueprints, step-by-step).

CMS, API, Mobile: Sylius integrates into all environments

The CMS debate between Sulu, DegDitor, and Monsieur Biz demonstrated the vitality of the ecosystem: Sylius no longer seeks to do everything, but to interface well. Headless commerce is finally finding its balance between flexibility and robustness.

On the mobile side, the presentation by Dominique De Vasconcelos, Célia Maure and Jérôme Caluory on the deployment of a B2B application connected to the Sylius API perfectly illustrates this openness: a single base, several interfaces, and a consistent user experience across all channels.

Artificial intelligence, useful and integrated

Above all, SyliusCon 2025 marked a shift in the way we approach AI. Gone is the fascination with giant models, and now comes useful integrations.

With Nicolas Potier and Sabrine Ferchichi, conversational AI is making its way into commerce: a shopping assistant integrated into WhatsApp shows how Sylius can open up to conversational commerce.

Magda Sadowska pursued this vision with a developer-centric approach. The integration of Codex and the Model Context Protocol (MCP) simplifies documentation, accelerates research, and streamlines collaboration. AI is no longer a gimmicky feature, but an integrated productivity engine.

Here is a summary ready to be included in the Darkwood blog post of Magda Sadowska's talk (“AI and Sylius: A Promising Partnership”):

AI at Sylius: not a magic wand, a multiplier

Thesis

At Sylius, AI is neither imposed nor “autopilot”: it’s a measured tool that augments a small team (≈20 people) to deliver better and faster. We measure first, we adopt later, and we keep what proves its value.

Principles of use (that really work)

  • Rich context > model: objectives, files, constraints, “done well” criteria. * Planning mode (30 s) before briefing the AI → less back and forth. * Small scopes + frequent context reset. * Rubber-ducking: AI as clarifier (explaining unknown code, change log). * Never mandatory: dissemination is done through short demos and “repeatable wins”. * Seniors set safeguards; juniors explore and find useful patterns. * Lucid reminder: studies show that seniors can be slowed down by AI → we target the right cases (unknown code, onboarding, research, translation/explanation).

4 concrete initiatives boosted by AI

  1. MCP (Model Context Protocol) for Sylius

    • “USB-C of AI”: an agent can call real tools from the store (e.g., place an order). * In progress: MCP integration layer for guided setup (payments, taxes, shipping), troubleshooting (“why does the checkout fail in FR?”), CRM/PIM, live rates, labels, etc. * Targeted KPIs: fewer admin clicks, faster demos, clear audit logs of agent actions.

  2. Store Wizard (demo generator)

    • Generates a Sylius demo (catalog, visuals, structure) in hours from a brief. * Inspired the installation of plugins & themes via UI (PoC validated).

  3. AI Context Packs for 1.x → 2.x Migrations

    • Rich contexts (BC breaks, checklists, hooks, APIs) that the AI uses to suggest changes and highlight risks. * Dev remains in the driver's seat; goal: quickly unlock plugins & projects. * Planned release of plugin compatibility hints + sharing of upgrade contexts.

  4. Redesign of the doc (2.x)

    • AI-assisted migration (repo + old docs + internal rules) to more accessible, up-to-date (hooks, APIs) and better interlinked (Symfony, API Platform) docs.

Also, marketing & research side

  • AI is used for landscaping, monitoring (pricing, changelogs, doc quality), cross-linking — always with human review.

What Darkwood Holds Back

  • Measure > “hype”: we keep what reduces cycle time, bugs and publisher friction. * Investing in context improves quality more than changing models. * Golden cases for us:

    • Accelerated POC demos (Store Wizard), * Guided setups via MCP (ready-to-use payments/shipping), * Assisted Sylius 2.x upgrades (context packs), * AI-clarified docs/procedures.

Roadmap on the Sylius side

  • Extend MCP (config, troubleshooting, guidance). * Replace unsuitable AI tools; standardize useful contexts. * Publish compatibility guides and share upgrade contexts with the community.

Magda's key message: AI didn't change the team—it changed the way work was orchestrated. No magic, but practices that turn good ideas into results.

Finally, Andrzej Michałowski and Mike Korba explored the future of personalization through Large Behavioral Models (LBMs), systems capable of interpreting user behavior with the same precision as language. Hyper-personalization becomes measurable, contextualized, and truly actionable.

Andrzej Michałowski opened his conference by tracing 12 years of personalization evolution, from classic recommendation systems to unified real-time architectures. At Synerise, his company, over 1.8 billion personalized messages and 4.6 billion recommendations are generated each month via email, SMS, push, and WhatsApp. The central idea: personalization is no longer a marketing module, but a system for orchestrating customer interactions.

  1. The three pillars of modern personalization

Data always up to date. Synerise has designed its own behavioral data-oriented database, capable of performing segmentations on the fly (decision in 10–20 ms).

AI not as a substitute, but as an amplifier. AI makes it possible to combine simple signals (name, loyalty points) with complex predictions (propensity, churn, likely products).

Execution must be unified: data, content, channels and CRM in a single platform, with low-code automation and omnichannel tracking.

  1. Large Behavioral Models: post-LLM

Andrzej introduced the concept of Large Behavioral Models (LBM):

Fundamental models trained not on language, but on behavior.

Just as LLMs predict the next word, LBMs predict the next customer action: click, purchase, visit. Once the basic model is built, it becomes trivial to create specialized models for specific use cases (recommendation, churn, scoring) in a matter of hours, instead of weeks. Synerise's results already exceed those of similar work published by Meta and DeepMind.

  1. A real case: Decathlon Poland

The example presented was telling: the Decathlon.pl site personalizes the entire experience in real time:

Dynamic banners based on purchasing propensities;

Categories, brands and products suitable for the session;

Shopping cart recommendations and contextualized product pages;

Emails and push notifications aligned with the overall journey. Each interaction instantly adjusts recommendations, proving the feasibility of session personalization at scale.

  1. The Synerise x Sylius plugin

In conclusion, Andrzej announced the release of a Synerise plugin for Sylius, allowing to:

Automatically synchronize customer and product data;

Leverage customization from the out-of-box;

Real-time event capture (transaction, shopping cart, visit);

Deploy multi-channel scenarios without code.

  1. Towards Behavioral CMS

Finally, he introduced a new concept: Behavioral CMS, a fully headless content system that draws directly on behavioral data to generate and personalize content without manual integration. This CMS centralizes content, CRM, and product data for an experience that's always fresh, consistent, and contextual.

🧩 In summary

Andrzej Michałowski places personalization in a global framework:

Unified behavioral data, fundamental models trained on human action, and automated omnichannel execution.

Sylius thus becomes a brick within a data-centric architecture, where AI does not replace marketing, but streamlines it.

Smoother, cleaner development

Developer usability (DX) is also progressing. Loïc Frémont and Estelle Gaits presented a modernized Sylius Grid based on the new PHP attributes #[AsGrid], #[AsFilter] and Symfony UX LiveComponent, for a responsive back office without custom JavaScript.

For his part, Stephan Hochdörfer recalled the importance of a reproducible development environment with DDEV: no more configuration divergences, less friction between teams.

Here is an editorial summary (ready to paste into the Darkwood article) of the CMS panel: Johannes Wachter (Sulu), Filippo Maria Tasca (DegDitor), Jacques Bodin-Hullin (Monsieur Biz), with the Sylius CMS (core) perspective.

CMS & Sylius: choosing the tool at the right level of complexity

Starting problem

You're launching a store, the marketing team asks "can we edit just this small block?" → we need a CMS. The panel asks the right question: which CMS for which context (team size, content importance, e-commerce constraints)?

DNA of solutions (why they exist)

  • Sulu (Johannes – Sulu CMS) Born in the DACH (DE/AT/CH): multilingual/multi-portal from birth, symfonic, thought of as a “content application platform”. Double pillar: robust technical base + very neat editor UX. * DegDitor (Filippo) Started from the needs of merchants (ex-Shopify, luxury/fashion): front-end productivity and editor freedom (live preview, drag-drop, cloning), front/back decoupling to iterate quickly. * Monsieur Biz CMS (Jacques) 100% Sylius CMS plugin ecosystem (rich editor, homepage, menu, pages): dev flexibility, zero synchronization on the store side, simple DX to add “homemade” blocks. * Sylius CMS (core vision – Nico) Minimal and simple plugin: base understandable by any Symfony/Sylius dev, extensible without friction. Intentionally non-exhaustive: if the content becomes strategic, move upmarket.

What everyone does “best”

  • Sulu: internationalization & multi-site on point, advanced editor UX, front-end performance, and “enterprise” ecosystem (ERP, PIM, integrations). * DegDitor: front-end productivity (autonomous front-end devs), modern editor experience (live preview, cloneable blocks). Ideal when the content “tells” the product (lookbooks, editorials, landing pages). * Monsieur Biz: pragmatic flexibility within Sylius, very quick implementation, safe by design for non-techs, while letting devs create custom UI blocks. * Sylius CMS: simplicity and minimal time-to-value for basic needs (a few pages/blocks), perfect for getting started and prototyping.

For whom / when?

  • Small teams, “nice to have” content (B2B, little editorial) → Sylius CMS (starter), then Monsieur Biz if rich blocks are needed. * “Content-driven” brands (fashion, luxury, storytelling, numerous landing pages) → DegDitor (front-end autonomy + UX editor). * “Enterprise” environments (multi-country, ERP/PIM, editorial workflows, large content team) → Sulu (specialized, decoupled, scalable CMS).

Rule of thumb: Measure the size of the content team rather than the size of the catalog. The more editing/approval/SEO is a major factor, the more a specialized CMS is required.

Collaboration & UX editor

  • Sulu: AI is seen as a feature engine in the UI (buttons, fields, search), not just a chat. * DegDitor: front-first, React editor with live preview, fine control of what the editor can modify (guardrails via YAML of the blocks). * Monsieur Biz: rich modular editor + preview (currently being improved), platform-side security; we don't expose the editor to breaking the front. * Sylius CMS: sober by choice, the UX depends a lot on how the dev extends it.

AI & Automation (positions assumed)

  • Sulu: integrates AI into UI (assisted SEO, content optimization) + prepares a “provider-agnostic” AI platform (key, prompts, GDPR, multi-vendors) for agencies. * DegDitor: experiments with translations, content generation, pages via YAML, and Figma → blocks bridge (sketch → component). * Monsieur Biz: targets AI to accelerate the creation of new UI blocks (MCP/LLM for scaffolding). * Sylius CMS: does not pursue “editor” AI as standard (strategic choice: let specialists take care of it).

Total Cost of Ownership (TCO)

  • Sulu: OSS, no license; requires experienced Symfony devs; runs from VPS to scalable cloud (K8s, functions). * DegDitor: ~2,500 € one-off license per primary domain (+ 4 subdomains), starter pack to reduce time-to-market; after block creation, little back-end required. * Monsieur Biz: quick installation (Composer); perfect for juniors on block creation; low adoption cost if already on Sylius. * Sylius CMS: MIT, cost = learning + customization; ideal for starting small.

Darkwood Reco (express decision grid)

  • Immediate need, small team, 5–10 pages → Sylius CMS. * We want to stay with Sylius but beef up the editing → Monsieur Biz CMS. * Responsive front end, demanding marketing, lots of templates → DegDitor. * Multi-site, multi-language, big workflows & integrations → Sulu.

Key idea: start integrated (marginal cost), move up in specialization when the content team grows and content becomes a business lever (SEO, storytelling, campaigns).

Here's a Darkwood blog post-ready summary of Ksenia Zvereva's talk (“Scope, Iterate, Deliver”):

Scope, Iterate, Deliver: The Product Survival Kit for Tech Teams

The thesis

Stop piling up features and chasing emergencies: frame the problem, limit the appetite (time), ship small and often, then iterate with real signals. The goal is not “more code,” but more impact.

The 3 big traps to avoid

  • Functional over-commitment: inflating scope, slipping dates. * Resistance to change: inability to integrate market insights along the way. * Late validations: coding based on untested assumptions.

Guiding principles (to be applied by the whole team, not just the PO)

  1. Shared product mindset: devs, design and PO co-own the outcome (not just the output). 2. Outcomes > Output: prioritize the business/user effect, not the quantity of tickets. 3. Shape before coding: clarify problem, constraints, pitch → then solution. 4. Define the “appetite”: “How much time are we willing to invest?” → fixed time, flexible scope.

Pragmatic techniques

  • Rapid prototyping (hours, not days): clickable mockups to validate journey and hypotheses before the build. * Dedicated cycles (e.g. 6 weeks): out-of-cycle (shaping/betting) → in-cycle (build focus, no distractions) → cool-down (feedback, debt, “little extras”). * T-shirt sizing (S/M/L/XL): common effort language, better load forecast. * Feature flags / incremental deployment: deliver to production under flag, activate 2–5–10% → measure → expand or rollback in 2 clicks. * Pre-mortem (30–45 min): list before go-live what can break (DB, latency, security, LB), and put in place simple countermeasures.

Delivery Mantra

Ship at 70–80%, put it in front of real users, learn, and iterate. “GA” is not an end, it’s a stream of continuous improvement.

What Darkwood Holds Back

  • Cadence > heroic performance: a team wins through controlled cadence and controlled risk. * Quality comes from the framework (shape, appetite, flags), not from a “magic” sprint. * These practices apply as is to Sylius/Symfony projects (flags, cycles, sizing) and drastically reduce slippage.

Mini checklist (30 days)

  • Institute shape doc (1 page) for any topic > 2 days. * Adopt T-shirt sizing in the current backlog. * Implement 1 feature flag end-to-end (CI/CD → progressive activation). * Plan a focus cycle (2–6 weeks) + dedicated cool-down. * Hold 1 pre-mortem before the next go-live.

Here is a summary ready to be included in the Darkwood article of the talk by Loïc Frémont & Estelle Gaits (“Pole position on the grid”):

Sylius Grid: Turbo DX, Live UX and Total Decoupling

The key idea

The Grid Bundle becomes a universal data grid (Sylius 1 & 2): less YAML/boilerplate, more PHP attributes, custom data providers (without Doctrine), and a responsive UX with Symfony UX Live Components. The result: fast, modular back offices, ready for non-e-commerce cases.

What's new that matters

  • make:grid generator: now works with any PHP class (not just Doctrine entities). * Attributes

    • #[AsGrid(...)]: Declares provider, resourceClass, name; __invoke() method instead of buildGrid() (SRP, cleaner code). * #[AsFilter(...)]: Symfony form type, Twig template, filter alias — everything is co-located in the class. * Providers without DB: Demo with OpenF1 (three steps: empty → hard data → API). The provider applies the criteria (e.g. country) and serves the objects to the grid. * Navigation “related grids”: Actions that pre-filter another grid (e.g. “Team radios” button → grid already filtered by driver).

Responsive UX (experimental)

  • Replaced grid Twig blocks with a Live Component (via Twig hooks). * Pagination, page/limit switching, filters → without reloading. * Multiple grids on the same page, each pre-filtered. * Live components provided for select, string, tab filters (update “as-you-type”).

What this changes for us (Darkwood)

  • Back-offices without custom JS: #[AsGrid]/#[AsFilter] + Live Components are sufficient in most cases. * Heterogeneous sources (API, files, internal services) without Doctrine: ideal for ops/transverse screens. * Less state on the front end, more clarity on the PHP side (attributes, providers, localized templates).

Mini adoption checklist

  • Migrate an existing grid to #[AsGrid] + __invoke(). * Extract a provider for a non-DB source. * Create a custom filter with #[AsFilter] (type + template). * Connect two grids via action + criteria. * Activate the Live Component on a screen (pagination & filters without reload).

In short: Grid Bundle 1.14 puts DX in pole position and paves the way for responsive, API-first admin panels – with Sylius as the chassis, regardless of the data engine.

DDEV for Docker dev environments… without the pain, not Stephan Hochdörfer (BitExpert)

Why DDEV?

Born in the Drupal community, DDEV is now a generic open-source tool that hides Docker complexity for local developers. Ideal if the team doesn't want to "talk Docker" on a daily basis, while maintaining its benefits (isolation, reproducibility, multi-project).

Live demo (with a few surprises 😉)

Stephan started a project from scratch:

  • ddev config → generates .ddev/config.yaml (project name, type Symfony/Drupal/… , docroot, PHP version). * ddev start → builds one image per project with the correct UID/GID (no more root files). * ddev launch → opens the local URL (no more need to remember domains). * Built-in commands: ddev console (alias of bin/console), ddev exec, ddev logs -s db, ddev import-db/export-db (MySQL/PostgreSQL agnostic). * Custom commands (e.g. ddev bootstrap) to chain Composer/Yarn/migrations — the “executable doc” of your README.

Add-ons & services

An add-on registry allows you to add Redis, OpenSearch/Elasticsearch, Varnish, etc. via ddev add-on get …. Stephan showed how to package your own add-ons (e.g. Algolia) with service dependencies.

IDE & DX

The DDEV plugin for PhpStorm (now maintained by the DDEV team):

  • Autoconfigures PHP, Docker, PHPUnit, Xdebug ("xdebug on" and it works). * Updates the project's DB/Redis connections. Result: we code, not wire.

Web servers & exotic stacks

Beyond Apache/Nginx, DDEV can run on a generic web server:

  • Example shown: FrankenPHP (dedicated Dockerfile + generic_webserver + daemon command). * DDEV can also drive bun.js, Spring Boot, etc. as long as an HTTP endpoint is exposed.

Sylius: test-app & plugins

Sylius Wink: Stephan plugged the Sylius test-app into DDEV to quickly test plugins (injected DB/Redis env, aka vendor/bin/console). Useful for maintaining a plugin on Sylius 1 & 2.

Stop properly

  • ddev stop: Stops the project's containers. * ddev poweroff: Also shuts down global containers (traefik, ssh).

What we remember for our projects

  • Faster onboarding: 4–5 orders and a workstation is up and running. * Fewer human errors: images per project, aliased orders, standardized add-ons. * Better quality: ddev scripts = reproducible procedures (local CI/CD). * Sylius gains: rapid plugin testing, multi-versions, modular B2B/B2C stacks.

In short: DDEV gives you the power of Docker without the friction—perfect for e-commerce teams (Sylius, Symfony, etc.) who want to deliver quickly, cleanly, and without hunting for ports or container IDs. Oh, and yes… it had stickers 😄.

Five underlying trends to remember

  1. Upgrade-as-a-discipline: version upgrades become a managed and measurable process. 2. Cloud-native by default: containers, messaging, CDN and FrankenPHP as the basic foundation. 3. Agent-oriented APIs: a new generation of APIs designed to interact with autonomous agents. 4. Unified DX: Symfony UX + redesigned Sylius Grid = responsive back-office without front-end complexity. 5. Pragmatic AI: intelligence integrated into the value chain (doc, data, decision), not just into visible functionalities.

In conclusion

SyliusCon 2025 not only confirmed the framework's technical solidity; it revealed a mature, structured community aware of its challenges. Sylius is becoming a strategic foundation, capable of tackling the complexity of modern commerce, without sacrificing code quality or freedom of integration.

The maturity of the Sylius ecosystem is now based on three pillars: standardization, scalability and intelligent integration.