Tech Stack
Which tools does the Storefront Application V3 run on, and why those? Every dependency is a mainstream, actively maintained open source project with its own public documentation and community. Alongside them sits a small set of SCAYLE npm packages, listed at the end of this page.
The stack fits together as one deployable unit. A single Node.js process runs an HTTP server that renders Vue pages server-side and answers the API calls your browser code makes afterward. TypeScript covers both sides, Vite builds both outputs, and you deploy one self-contained build artifact to Storefront Hosting. Read Layers and Data Flow for how server, client, and shared code are kept apart, and Pages and Controllers for how a request becomes HTML.
Every tool below is yours to change. Swapping one out is a real cost, because the SDK packages expect Hono middleware, Inertia page responses, and Vue components, so the further down the stack a replacement sits, the more of your own code it touches.
Core and client
Vue 3
Vue 3 is the view layer. It runs on the server during rendering and in the browser after hydration, so one component tree covers both. You write pages and components with the Composition API.
The surrounding Vue libraries are already installed: VueUse for server-safe composables, vue-i18n for translations, and Regle for form validation. Both entry points, src/client/main.ts and src/client/ssr.ts, install the i18n instance that src/i18n/config.ts builds. You import VueUse and Regle directly in the component or composable that needs them.
Inertia.js
Inertia.js connects server-rendered pages to the Vue client. Your server returns props, Inertia renders the matching Vue page, and every navigation after the first one transfers JSON instead of a full HTML document.
You get the development model of a classic server-rendered application with the interactivity of a single-page application. There is no client-side data-fetching layer to keep in sync with the server, no duplicate route definitions, and no separate API contract to version for page data. Partial reloads and deferred props let you ship the fast parts of a page in the initial HTML and stream an expensive block in afterward.
Tailwind CSS
Tailwind CSS v4 provides the utility classes and the design token layer. Tokens live in CSS @theme blocks rather than a JavaScript config file, so your brand colors, spacing, and typography are plain CSS custom properties you can read and override. They sit in src/client/design-tokens.css, which src/client/index.css imports.
Styling stays next to the markup it applies to, so you can understand a component without opening a separate stylesheet, and deleting a component deletes its styles with it. Unused utilities never reach the browser bundle. Version 4 compiles through a Vite plugin, so changes appear immediately in development.
Server
Hono
Hono is the HTTP server and router. It serves page requests and API requests from the same process, built on the web standard Request and Response objects rather than a framework-specific abstraction.
Hono is small and fast, and its middleware is a plain function, so src/server/index.ts reads top to bottom as the list of stages a request passes through. Configuration, sessions, and caching arrive as one stage there, because the SDK mounts them together. Hono itself targets web standards and runs on several JavaScript runtimes, but the Storefront Application targets Node.js, see Node.js. Read Pages and Controllers for how a request becomes a page, and RPC API for how API routes are mounted.
oRPC
oRPC is the type-safe layer for everything the browser calls after the first render: adding to basket, signing in, applying a promotion code. You define a procedure once with its input and output schemas, and the browser client receives full TypeScript types for it with no code generation step.
Changing a procedure's input becomes a compile error at every call site instead of a runtime failure in production. Input is validated at runtime with Zod, so a malformed request is rejected before your handler runs. Read RPC API for how to write a procedure.
oRPC also generates an OpenAPI document from the same procedure definitions. RPC API covers the generated reference, which is on in development only by default, and what a call to /api carries.
Runtime
Node.js
Node.js is the server runtime. The engines field in package.json names the major version the application is built and shipped against, and the Dockerfile pins the exact image.
pnpm
pnpm is the package manager. A content-addressed store keeps one copy of each package version on disk no matter how many projects use it, which keeps installs fast and disk usage low.
pnpm is also strict about what your code is allowed to import. By default a package you didn't declare as a dependency isn't importable, so an accidental transitive import fails immediately instead of breaking later when an unrelated upgrade drops it. Workspaces and catalogs keep versions aligned when you split your storefront across several packages.
Build and developer tooling
Vite
Vite is the bundler and development server. In development, it serves modules natively and hot-reloads a changed component without a full page refresh. At build time, it produces two outputs from one configuration: a Node.js bundle for server rendering and a browser bundle for the client.
Vite's plugin ecosystem is where Tailwind CSS, Vue, and telemetry instrumentation hook in.
Browser support
The application runs in Chrome and Edge 119 or later, Safari 17.4 or later, and Firefox 128 or later. A dependency, newer CSS in the application, or your own code can raise that floor.
The application sets no build.target and no browserslist, and nothing checks browsers for you. Three sources set the floor. Vite 8.x builds for its default target, baseline-widely-available, which is Chrome and Edge 111, Firefox 114, and Safari 16.4. Tailwind CSS v4 names Chrome 111, Safari 16.4, and Firefox 128. The client code calls Promise.withResolvers(), which MDN lists from Chrome 119, Firefox 121, and Safari 17.4. The highest of the three per browser is the floor.
The application adds no polyfills for missing browser APIs. Check a new API or CSS feature on Can I use before you rely on it.
TypeScript
TypeScript covers the entire codebase, server and client. A field you add to a shared type on the server is visible in the Vue component that renders it, and removing a field is reported instead of silently rendering nothing.
vue-tsc checks .vue templates too, so a mistyped prop name is reported rather than showing as a blank spot on the page. It runs as the separate pnpm typecheck script, not as part of pnpm build, so keep it in your pipeline alongside the build.
ESLint
ESLint enforces correctness and consistency. eslint.config.mjs starts from a shared SCAYLE preset that brings rules for Vue, accessibility, Tailwind classes, and translation keys. The file passes the preset your Tailwind entry point and your locale directory, then adds the import boundaries between server, client, and shared code.
A missing translation key, an image without an alt attribute, or a client file importing server code fails lint instead of reaching review or production. The rules are plain configuration, so you can relax or extend them for your own code.
Prettier
Prettier formats every file it recognizes, and the Tailwind plugin sorts utility classes into a canonical order.
Testing
Vitest
Vitest runs the unit and component tests. It shares the Vite configuration, so tests resolve imports and path aliases exactly the way the running application does. Unit Testing covers how to write a test.
vitest.config.ts splits the tests into projects per layer. Component tests run against a DOM implementation, and the rest run in Node. There is no second build pipeline to configure or keep in sync with the application, and watch mode is fast enough to leave running while you write code.
Playwright
Playwright runs end-to-end tests in real browsers against a running storefront. The suite in testing/playwright/ drives pages such as the homepage, product listing and detail pages, search, basket, wishlist, promotions, and account, and it reaches checkout and places a test order, see End-to-End Testing. It can also scan your pages for accessibility problems, see Accessibility Testing.
Storage
SCAYLE KV
Sessions and cached responses live in SCAYLE KV, the managed key-value store you get with Storefront Hosting. The SDK connects to it with the Valkey GLIDE client in cluster mode.
Session state and cache entries have to outlive a single request and be shared by every instance behind the load balancer, which an in-process memory store cannot do. Because SCAYLE KV is managed, you do not run, patch, or scale it yourself.
Access goes through unstorage, a driver-based abstraction, so one code path covers development and production. Cache and SCAYLE KV lists the connection and compression settings, including how to point development at a single Redis or Valkey instance. Read Session and Authentication and Caching for configuration.
Observability
OpenTelemetry
OpenTelemetry is the instrumentation layer. It traces incoming HTTP requests using the OpenTelemetry semantic conventions, follows outgoing calls into the same trace, and records runtime metrics. You choose where all of it goes with the standard OTEL_* environment variables.
OpenTelemetry is vendor-neutral, so you send telemetry to whichever observability platform you already use, and moving to a different one is a configuration change rather than a rewrite. Because instrumentation is built in, a slow page is traceable down to the individual Commerce Engine call without you adding timing code by hand. Read OpenTelemetry for the variables that configure it.
SCAYLE packages
Alongside the open source stack, your storefront depends on a set of SCAYLE-published npm packages. They install and upgrade like any other dependency.
@scayle/storefrontis the runtime framework. It provides the core business logic to run your e-commerce shop on SCAYLE and lets you benefit from future feature development. It also brings the storage drivers that back sessions and caching, so you never install those yourself.@scayle/storefront-apiis the framework-agnostic client for the SCAYLE Commerce Engine. Every call to the Commerce Engine goes through it.@scayle/storefront-buildis the Vite plugin set that produces the server and client builds and injects your resolved storefront configuration.@scayle/storefront-opentelemetryprovides the Hono middleware and Vite plugin for tracing.@scayle/storefront-devtoolsis a development-only Vite plugin, described in Storefront DevTools. It adds a dock with an Inertia.js visit inspector, an oRPC call inspector, a storefront context viewer, Vue DevTools, and Vite Inspect.@scayle/storefront-cms-storyblok,-contentful,-contentstack, and-amplienceintegrate a content management system.CMS_PROVIDERselects the one your shop uses at build time, and the build drops the rest.@scayle/eslint-config-storefrontand@scayle/prettier-config-storefronthold the shared lint and formatting rules.
Read Extending the SDK for how mappers and services work and how to override them.