Sylius B2B: Pairing the Symfony Backend with a Composable Storefront

Sylius is one of the most extensible open-source commerce backends available today, built directly on Symfony and designed to handle complex B2B logic without the workarounds most platforms require. The bottleneck is rarely the backend. It is the frontend: teams that need tiered pricing, customer-group management, quotation flows, and multi-account logic quickly outgrow what Sylius themes can deliver.

This post explains how to keep Sylius as your backend core and place a fully capable Composable B2B storefront in front of it.

What makes Sylius well-suited for B2B commerce?

Sylius gives you a clean product, customer, and order layer on top of Symfony. For B2B scenarios, that translates to:

• Customer groups with dedicated pricing: Tiered pricing and group-specific catalogs are native Sylius configuration, not custom code.
• Quotation workflows: With Sylius plugins or custom bundles, an RFQ (Request for Quotation) flow is straightforward to implement.
• GraphQL API: Sylius exposes a GraphQL API that serves as the data source for any decoupled frontend.
• Symfony ecosystem: Development teams with Symfony expertise can extend Sylius deeply without switching to a proprietary framework.

What Sylius does not provide out of the box is a frontend that keeps pace with those B2B capabilities. Default themes are built for B2C purchasing flows and lack the UX depth that B2B buyers need in practice.

The problem many Sylius teams run into

B2B projects on Sylius typically hit a frontend bottleneck. The backend is well-structured: customer groups, pricing rules, permissions. But the frontend becomes the obstacle. Every B2B requirement that Sylius handles cleanly in the backend has to be rebuilt laboriously in the theme. That leads to:

• long development cycles for each new requirement (tiered price display, quick-order entry, quotation flows)
• technical debt in the form of theme overrides that break on Sylius upgrades
• a storefront that works but is hard for marketing to evolve independently, because every change requires an engineering sprint

There is also a structural issue. Teams running Sylius on PHP and Symfony often have no built-in path to a modern frontend architecture (Vue, Nuxt, React). The frontend stays Twig-based and falls behind on performance and flexibility.

This is exactly the gap that Composable architecture patterns address in practice: backend and frontend are cleanly separated, and each layer can evolve independently.

How to pair Sylius with a Composable B2B storefront

The approach is more direct than most teams expect. You keep Sylius fully intact as the backend and place a Composable Storefront on Nuxt in front of it. This works in three phases:

Phase 1: Verify the API layer

Sylius provides both a GraphQL API and a REST API. For a decoupled frontend, you use the GraphQL API as the primary data source. Check the following:

• Are customer groups and pricing rules accessible through the API?
• Can order workflows (including RFQ) be driven through the API?
• Is there existing authentication and token logic for B2B accounts?

In most Sylius setups these points are achievable with minimal effort, because Symfony middleware keeps concerns clearly separated.

Phase 2: Set up the Composable frontend

Laioutr connects to Sylius through the Composable Headless Frontend layer. That means:

• Nuxt app as the frontend base (SSR plus Edge Delivery for performance)
• Connection to the Sylius GraphQL API through the Orchestr connect layer
• B2B components: tiered price display, customer-group switching, quick-order entry module, quotation request form

These components are pre-built in the B2B Growth Kit and ready to deploy, without months of development time.

Phase 3: Hand off to marketing and iterate

Once the Composable frontend is live, the marketing team takes control of landing pages, campaigns, and content updates directly in Laioutr Studio. Engineering stays focused on component development and API extensions, not on updating prices on the homepage.

What you gain

FAQ

Do I need to touch Sylius to switch the frontend? No. You keep Sylius fully in place as the backend. The Composable frontend communicates only through the Sylius API. No changes to backend code are required.

Which Sylius versions are supported? Laioutr connects to Sylius through the GraphQL and REST APIs. This works with Sylius 1.x and Sylius 2.x as long as the API layers are enabled.

How long does the migration to a Composable frontend take? For typical Sylius B2B setups, the initial frontend rollout takes 4-8 weeks, depending on the complexity of customer-group logic and quotation flows.

Can the marketing team work independently after launch? Yes. After go-live, marketing works directly in Studio. Engineering maintains and releases components; marketing handles content and layout changes on their own.

Next steps

If you want to keep Sylius as your backend while moving to a Composable Commerce frontend, the most direct starting point is the Headless Frontend page for Sylius:

Check out the Headless Frontend for Sylius page to see the integration stack in detail.

Or book a demo to walk through your specific Sylius setup together.

More from the Laioutr Platform

• Headless Frontend for Sylius - Integration stack, architecture, and first steps
• B2B Growth Kit - Ready-made B2B components for punchout, tiered pricing, and quick order
• Composable Headless Frontend - Architecture foundation for backend-agnostic frontends
• Laioutr Home - Platform overview and book a demo
• All Insights - More articles on Composable Commerce strategy