Service · Software development

Custom design system development for multiple product teams.

A single source of truth for your colours, typography, components and interaction patterns. Available in Figma and as a code library, documented in Storybook, and built to be used by multiple teams at once without falling apart.

Design tokensComponent libraryStorybookMulti-brand themes

A design system is not a UI kit with a fancy name.

A UI kit is a collection of Figma components. Nice to look at, but as soon as several product teams start working with it, it drifts apart: colours deviate, spacing stops matching, buttons get reinvented again and again, accessibility slips team by team, and nobody knows which version is in production where. The Figma file gets steadily more out of sync with what is actually on screen.

A real design system links design and code through tokens, delivers a versioned component library, documents decisions in Storybook, and has governance to stop the system stalling after a few releases. We build that for scale-ups with multiple product teams, enterprises with a multi-product portfolio, and organisations that want to roll out a design system across multiple web applications.

The biggest promise is not visual consistency; that is a pleasant by-product. The real promise is speed: a team building a new page reaches for existing, validated components and delivers in days what would take weeks without a system. Accessibility is done properly once and then inherited everywhere. A rebrand becomes a token change, not a project per application.

Three roles we step into.

Not every engagement starts from zero. Sometimes a Figma library already exists, sometimes there is only a brand refresh, and sometimes an existing system needs to scale across multiple brands. We adapt our role to where you are.

Greenfield · built from scratch

Building a new design system

You are partway through scaling up, you have two or three product teams each inventing their own UI, and now you want one system that works everywhere. Together with your design team (or our design partner), we lay the foundation: tokens, base components, Storybook, and a first release for pilot teams.

Design tokensComponent libraryStorybooknpm package
Migration · from CSS frameworks to tokens

Renewing an existing system

You have a legacy stylesheet, a Bootstrap fork from earlier years, or a Figma library that no longer reflects what is in production. We migrate step by step to a token-based system, maintain backwards compatibility where needed, and provide codemods so your teams can swap old components for new ones.

Style DictionaryTokens StudioCodemodsDeprecation paths
Multi-tenant · white-label themes

Theming for multiple brands

You provide a platform to customers who want to offer it in their own branding, or you have a brand portfolio with several labels on the same codebase. We make the design system themeable: tokens can be overridden per tenant, components adapt, and your customers can apply their own colours, typography and logo through a config. A good fit for a multi-tenant platform.

Theme tokensBrand overridesRuntime themingTenant config

What a design system includes.

The concrete deliverables: not a marketing layer, but the building blocks your teams work with every day. Below are the standard components we build or help build, depending on where you are. Not every engagement needs everything at the same depth: an organisation with one product team needs less governance than an enterprise with fifteen teams and three brands.

  • Design tokensColour, typography, spacing, shadow, radius, motion curves — stored as JSON/YAML and published as CSS variables, JS objects and Figma variables via Style Dictionary or Tokens Studio.
  • Component libraryReusable UI components: button, input, modal, dropdown, navigation, data table, form controls, toast, tabs. In Figma as instances and in code as framework components.
  • Code implementationReact, Vue, Angular or Web Components — depending on your stack. Published as an npm package (public or via a private registry) with semver versions.
  • Storybook documentationEvery component with do's and don'ts, a props table, accessibility notes, usage patterns and code snippets. It doubles as the playground where designers and developers experiment.
  • Accessibility built inWCAG AA as the baseline, AAA where possible. Keyboard navigation, screen-reader labels, visible focus states, sufficient contrast — tested with axe and Playwright, not bolted on at the end.
  • Theming layerTokens can be overridden per brand, tenant or mode (light/dark/high-contrast). The component code stays the same; only the tokens change.
  • Versioning & migration guidesSemver, a planned deprecation path for components being phased out, and written migration notes with every major release so product teams know what they need to change.
  • Adoption toolingESLint rules that flag deviations, a dashboard showing which team is running which version, and visual regression tests via Chromatic that stop components from shifting unnoticed.
  • Governance modelA workable contribution model (who can contribute, who reviews, how an RFC is submitted) so the system stays alive instead of freezing after the first release.

When a design system pays off.

Not every organisation needs one. Below a certain scale, a simple UI library is enough. Below are the patterns in which a serious design system quickly pays for itself.

Scale

Multiple product teams

You have two or more product teams each working on their own screens. Without a shared foundation they will drift apart — different buttons, different modals, different form states. A design system makes reuse legitimate instead of a source of bugs.

Multi-product

Portfolio of multiple apps

You deliver several applications that customers see as one brand. A user switching between your apps shouldn't have to relearn different navigation or form conventions.

Rebrand

Rebrand plus scaling up

You are in a rebrand or an M&A integration where two brands come together. A token-based system means the visual rebrand only has to happen once, rather than per application.

White-label

SaaS with customer themes

You deliver software that customers want to offer to their own users in their own branding. A theming layer is then not an option but a core feature. See also multi-tenant platform and enterprise software projects.

Not sure about a large project yet?

Test your idea first: a working prototype in 1 day

With OneDayBuild, we make your idea tangible in a single day for €1,150, so you know whether further development is worth the investment. Decide to go ahead with the full build? Then we deduct the cost in full.

View OneDayBuild →

How a project runs.

1

Inventory & baseline

We map out what already exists: current Figma files, production screenshots, CSS archaeology, per-team conventions. This is followed by an audit of the pain points the system needs to solve — often: inconsistent buttons, inaccessible form states, colour chaos, no single source of truth.

2

Token architecture & base components

We define the token layer (colour, type, spacing, motion) and the first layer of components: button, input, label, link, card, modal. These go straight into Figma and into code so designers and developers can work in parallel. We choose the token architecture deliberately: three layers (primitive — semantic — component), so a later rebrand is a matter of adjusting the semantic layer rather than redrawing every component.

3

Storybook & first release

Documentation is written alongside the code from the start. Not as a post-launch chore, but as a living spec: no Storybook page, no merge. The first npm release is a 0.x for the pilot teams.

4

Pilot with one team

One product team goes into production with v0.x. We deliberately keep it small: the team gives feedback, we iterate, and only then do we roll out. This prevents us from delivering a beautiful system that doesn't fit real screens in practice.

5

Adoption roll-out

Wider roll-out to the other teams. Support comes through weekly office hours, a Slack channel where teams can ask questions directly, codemods for migration, and linters that flag deviations (non-standard colour values, hardcoded spacing, use of legacy components). We monitor which team is running which version, so adoption is measurable, not assumed. A dashboard shows live how far the roll-out has got and where drift appears.

6

Governance and ongoing development

The system lives on. New components are contributed through an RFC process, breaking changes go out as semver-major releases, and we monitor visual regressions with every release. Optionally, we stay involved as maintainer, or we hand it over completely to your internal team.

Frequently asked questions.

What clients usually want to know before we start a design system project.

What is the difference between a UI kit and a design system?
A UI kit is a Figma file with components. It looks good, but it is design only: there is no code alongside it and no documentation beneath it. A design system is design and code, linked through tokens, documented in Storybook, versioned via npm and governed through a governance model. The difference is practical: a UI kit shows how something could look, while a design system makes sure it works that way in production, and keeps working when three teams are pulling at it at once.
We have our own design team. Will you work with them?
Yes, usually. In greenfield projects, our engineering team works alongside your design team. We translate Figma into tokens and code, while your team keeps the final say on visual direction and brand choices. In projects where you don't yet have design capacity, we bring a dedicated design partner. We don't design endless marketing styles ourselves, but make sure the design results in a working code system. We agree the division of roles clearly up front: who designs which component, who reviews accessibility, and who has the final word on a token choice.
Can you build just the code library if we already have the design?
That is a common starting point. You have Figma components but no versioned code library yet. We then implement the components in your framework (React, Vue, Angular or Web Components), publish them as an npm package, set up Storybook and build the adoption tooling. The design is yours; the usable code implementation is ours.
How do you handle accessibility?
Accessibility is built in from the start, not left to a final check sprint. In practice: WCAG AA as the baseline requirement (AAA for the public sector where requested), keyboard navigation and focus states on every interactive component, screen-reader labels via ARIA, sufficient colour contrast in every token, and automated axe tests in Storybook. Where contracts require it, we deliver a per-component WCAG conformance report so you can show customers or regulators that the fundamentals are in order. For healthcare and government projects where accessibility is a hard requirement, we align the test suite with the European Accessibility Act and NEN standards.
Does this also work for multi-tenant or white-label?
Yes, and it's actually a common use case. We build a theming layer in which tokens can be overridden per tenant or brand: colour, typography, logo and spacing can be set per client via a config file or runtime API. The component code stays the same; only the tokens change. It's a good fit for a multi-tenant platform or a SaaS portfolio offered to clients under different brands.
What determines the cost of a design system project?
The biggest variables are: the scope of the component library (10 basic components versus 60 including a data table and form builder), the number of frameworks that need to be supported (React only, or Vue and Web Components too), the degree of theming (a single brand or multi-tenant), and the amount of migration work in existing applications. We work with fixed sprint budgets, so you can steer where the time goes sprint by sprint.
How long does it take before the system is usable?
A first usable release (tokens plus 8-12 basic components plus Storybook) is ready after a few sprints and can already be used in a pilot team. The full system with all components, theming and adoption tooling is a project spanning several sprints. We usually build it out in parallel with the pilot, so the system grows step by step with input from real-world use.
What if our system stalls again after a year?
That's the most common problem with design systems: after the initial release, nobody has the time to review contributions and the system slowly fades out. Components get "quickly copy-pasted and tweaked" locally, drift builds up and the central system falls behind actual practice. That's why we always build in a governance model: a clear contribution path, RFCs for larger changes, a review board with both design and engineering representation, and adoption metrics so you can see which team is on which version. Optionally, we stay involved as maintainer, or we train your internal team to take it over, which also fits well alongside broader platform development.
Which tools and frameworks do you use?
Vendor-neutral: Figma for design (Sketch only for legacy), Style Dictionary or Tokens Studio for the tokens pipeline, Storybook for documentation, React with Radix primitives or Headless UI where the framework choice allows, and Vue 3 or Web Components if your stack calls for it. For distribution we use npm or a private registry (GitHub Packages, JFrog), Chromatic for visual regression and Playwright for interaction tests. We choose based on your stack, not on a fixed favourite.

Talk to us about your design system.

A no-obligation introductory call of half an hour. We listen to where you stand, whether that's an existing Figma library, a rebrand, a multi-product portfolio or a blank slate, and give you an honest picture of what a suitable project involves. We discuss what's realistic for your scale, which parts you can cover in-house and where we step in, and which risks are typical in a design system project. If it fits logically alongside a headless CMS project or a larger platform overhaul, we'll say so too.

Edit content