SCAYLE: Connect Your Own Frontend, Managed

SCAYLE explicitly invites commerce teams to connect their own frontend. The pitch, in plain terms: use our APIs, build your own storefront frontend, and here is a Nuxt 3 boilerplate plus the @scayle/storefront-nuxt SDK to get you started. That is an honest offer, not a marketing trick, SCAYLE positions itself deliberately as a backend, not a frontend vendor. The question that comes up less often in sales calls: who maintains that frontend in month 13, when the next SDK major version ships, or when marketing needs its third campaign page of the week?

The invitation: Nuxt boilerplate + @scayle/storefront-nuxt SDK

Start with SCAYLE and you get access to a public storefront boilerplate: a Nuxt 3 / Vue 3 foundation built around the @scayle/storefront-nuxt package, which ships composables for product, basket, and checkout data. The logic is straightforward, fork the repository, make it your code, build your storefront logic on top.

For a development team with capacity to spare, that is a solid starting point: TypeScript types for SCAYLE entities, a reference implementation for PDP, PLP, and checkout, an SDK that talks directly to the SCAYLE API. No reverse-engineering the API structure, no custom glue code for the basics. For teams that want to own their composable architecture end to end, it is a fair invitation.

What the fork actually costs

The boilerplate path has a catch that only shows up once you are in production: from the moment you fork, the entire maintenance burden is yours, permanently.

• Nuxt minor and major upgrades need to be tracked and applied manually
• @scayle/storefront-nuxt SDK version bumps mean breaking-change reviews in your own codebase
• Security patches for Node dependencies land in your backlog, not SCAYLE's
• Every new campaign page needs a pull request, every banner swap needs a deployment
• Marketing cannot touch the storefront directly, because there is no editor, only code
• Marketplace or storefront features SCAYLE ships after your fork point need to be rebuilt manually instead of arriving automatically

This is not a SCAYLE-specific issue, it is built into every bring-your-own-frontend approach. Still, it is worth pricing in honestly, before the fork becomes the repository with the biggest technical debt pile in the company.

Laioutr as the managed answer to that invitation

Laioutr answers the same invitation, just managed. Our Composable Headless Frontend itself runs on a Nuxt foundation, so SCAYLE teams find no framework break here. The difference sits at the operating layer: instead of maintaining a fork, you connect SCAYLE through our Orchestr data layer into the frontend. Product, inventory, category, and order data flow, normalized, into our component schema, the same data points the official SDK exposes, just without your team maintaining the connection itself.

That means you take SCAYLE up on its "bring your own frontend" invitation, without your team also running the frontend as its own separate operating system. The result is a Frontend as a Service: CI/CD, hosting, framework upgrades, and security patches are platform work, not your team's sprint work. Developers keep full access at the component layer, minus the fork upkeep.

How the technical connection works

Technically, the flow stays close to what the SCAYLE SDK already sets out to do. The Orchestr layer talks to the SCAYLE storefront API over GraphQL, pulls product data, pricing, availability, and basket state, and maps it onto our unified component schema. PDP, PLP, and checkout components in the frontend expect the same data shape, regardless of whether SCAYLE, Shopware, or commercetools sits behind it, the same advantage that carries our decoupling story on the backend side. Start with SCAYLE today, and if you evaluate a second backend in three years, you do not have to rebuild the frontend for it.

For engineering teams, that means concretely: you connect SCAYLE-specific fields, loyalty points, custom pricing rules, marketplace offers, for example, through custom resolvers in the Orchestr layer, instead of rebuilding them inside an SDK fork. The basics, product catalog, basket, checkout, orders, already exist as components and do not need to be re-derived from the SCAYLE SDK.

Who does what: engineering and marketing

The role split stays clean. Engineering teams define components, connect SCAYLE-specific data points through the Orchestr layer, and extend the component library with your specifics, discount logic, B2B price tiers, custom checkout steps, whatever your setup needs. Marketing works in parallel in the Studio editor, composes campaign pages, swaps banners, launches landing pages, all without a pull request and without waiting for a deployment window. A concrete example: when SCAYLE ships a new API field for B2B special pricing, an engineering team connects it once in the Orchestr layer, and the component is then available to every storefront using it, without marketing waiting on a second sprint.

With a forked boilerplate, that split does not exist, every change runs through code, whether it is content or structure. For teams with a high campaign cadence, seasonal collections, or frequent price and promo changes, that is the difference you feel every week.

Decision framework: fork, managed, or custom build

Three situations, three sensible answers.

You have a well-staffed frontend team of your own and want full pixel control from day one, with no platform layer in between. The SCAYLE boilerplate fork is the direct answer, with the maintenance load as a trade-off you are taking on knowingly.

You want to shorten time to launch, and marketing should be able to build campaign pages themselves, without tying up developer capacity permanently. Laioutr as a managed frontend layer over SCAYLE is the direct path, predictable in effort, without having to swap out SCAYLE as your backend.

You are comparing the frontend options for your SCAYLE setup at a broader level, boilerplate, managed platform, or a fully custom build from scratch. We laid out the full comparison in SCAYLE headless options compared. This article goes deeper specifically on the bring-your-own-frontend invitation and what the managed alternative means in practice.

Takeaway

SCAYLE's "connect your own frontend" invitation is a fair offer, for teams with the permanent capacity to maintain a frontend. For everyone else, Laioutr is the way to accept the same invitation: keep SCAYLE as your backend, use the Nuxt stack, but hand SDK maintenance, the deploy pipeline, and marketing capability to a Frontend Management Platform built exactly for that. The usual first step is a technical discovery call, where we map out together which SCAYLE data points your storefront needs today. More on the SCAYLE connection in detail: Headless Frontend for SCAYLE.