Solaris Boilerplate. Focus on design, not plumbing.
Our storefront starter kit. The foundation for optimised, proven, advanced theme development — ready-made API components, a hook architecture and full transparency. The heavy lifting is already done.
A finished storefront to redesign, not a template to fill in.
Solaris is a complete Next.js storefront wired to HDL Commerce: catalogue, search, product page, cart, checkout, account, B2B views and order history all work from the first commit. The data layer, the caching, the error handling and the performance work are done.
You start where most projects finish: in the design. Change typography, colours, layout and components — without first building the integration to the platform.
# Clone and start npx create-hdl-storefront my-shop --template solaris cd my-shop && npm install # Point it at your environment HDL_STORE_URL=https://demo.hdlcommerce.com HDL_API_KEY=hdl_test_… npm run dev → Storefront at http://localhost:3000 → Catalogue, checkout and account already wired up
Ready-made API components.
The building blocks already exist
Catalogue
Product
Checkout & account
Every component is unstyled by default and accepts your classes. The logic — calls, loading, errors, optimistic updates — lives in the component; the look lives with you.
All the data behind a hook.
import { useProduct, useCart } from '@hdl/solaris'; export default function ProductPage({ slug }) { const { product, variant, select, loading } = useProduct(slug); const { add, pending } = useCart(); if (loading) return <Skeleton />; return ( <article className="pdp"> <h1>{product.name}</h1> <PriceDisplay value={variant.price} /> <VariantPicker onSelect={select} /> <button onClick={() => add(variant.id, 1)}> {pending ? 'Adding…' : 'Buy'} </button> </article> ); }
The hooks wrap the entire data layer: caching, revalidation, optimistic updates, error handling and typed responses. You never write a fetch call against the platform unless you want to.
Full transparency.
No black box in the chain
Solaris ships as source code in your own repo. No compiled runtime, no hidden layers, no dependence on us to change one detail in the checkout.
All the logic is readable — the data layer sits in lib/hdl/ and can be followed line by line
Updates arrive as pull requests you choose to take
You can rewrite any component without losing the rest
The agency you hire owns the code with you, not the licence to it
End-to-end tests for the purchase flow come with it, so a redesign can be verified
Days to simple, weeks to advanced.
What a project looks like
Setup
Clone Solaris, point it at your environment, set the domain and environment variables. You can already shop in the store at this point.
Design
Tokens, typography, colours, component styling. A simple store can go live by the end of the week.
Your own flows
B2B views, configurators, promotion logic, custom page types and integrations with your systems.
Sharpening
Performance, SEO, accessibility, A/B testing and continuous development on the same foundation.
The timescales assume product data already in the platform and a settled design direction.
Without a starter kit
The first month goes on the data layer and caching
The checkout gets rebuilt three times before it is stable
Performance becomes an afterthought
The design comes last, once the budget is gone
Focus on design, not plumbing
The purchase flow works from day one
A proven checkout already running in production
Core Web Vitals designed in, not bolted on
The whole budget goes on what the customer actually sees
The performance work is already done.
Server components first
Category and product pages render on the server with ISR and on-demand revalidation when prices or stock change.
One call per view
The hooks combine what a view needs into a single call, with cache keys per channel and customer group.
Images at the right size
Image variants, format selection and lazy loading come preconfigured against the platform’s media handling.
Questions about Solaris.
Common questions
Do we have to use Solaris?+
No. The platform is headless and can be driven by any frontend. Solaris is the shortcut for anyone who wants to start in the design rather than in the integration.
Do we own the code?+
Yes. Solaris ships as source code in your repo and can be changed however you like. Updates arrive as pull requests you choose to take.
How is the kit updated without overwriting our design?+
Your design lives in its own components and tokens, separate from the commerce layer. Updates touch the data layer and the API components, not your styles.
Can we use our own design system?+
Yes. The API components are unstyled and accept your classes, so an existing design system can sit on top.
Does B2B work in Solaris?+
Yes. Contract prices, credit limits, buyer roles, quick order and order history all exist as components and hooks.
Can our agency build in it?+
Yes. It is an ordinary Next.js app with TypeScript. We give the agency its own API key with limited permissions and access to the repo.
What does it cost?+
Solaris is included for customers on the platform. See pricing for the plans.
See Solaris running your catalogue.
We start the kit against a test environment with your data and go through what needs redesigning for your store specifically.