Skip to content
UX

Design systems from Figma to production code

Design tokens, components and documentation in one pipeline, designed and built by the same people, so Figma and the code in production match.

  • Design tokens from Figma to code
  • WCAG 2.2 AA in every component
  • The people who design it build it

We build and run systems for

  • GlobalConnect
  • Sykehusinnkjøp
  • Home_Net
  • Telia

What we build in a design system

From an audit of what you have today to a system of tokens, components and governance that lasts for years.

  • Audit of your current interface

    We count colours, button styles and patterns in production and plan the clean-up.

  • Design tokens

    Colours, typography, spacing and shadows gathered as tokens in one format every platform can use.

  • From Figma to code automatically

    A pipeline turns tokens into CSS, Swift and XML and publishes them as a new NPM package.

  • Headless components

    React and TypeScript on Radix UI or React Aria, with your own style and proper keyboard navigation.

  • Inherited accessibility

    We test every component against WCAG 2.2 AA, so product teams get accessibility built in.

  • Governance and documentation

    A governance model, Storybook and guidelines that keep the system in use and well maintained.

When does a design system pay off?

A design system is more about speed, quality and risk than about looks, and does the most good when several teams build on the same brand.

  1. Several products, different looksThe same button exists in five variants across your products.

  2. Figma and the code disagreeDesigners draw one thing, and each team builds its own version.

  3. Accessibility requirementsAccessibility is tested once in the components and inherited by all.

  4. A library nobody ownsYou have components, but no documentation or governance.

Our own components score 100 in all four Lighthouse categories

The site you’re reading is built on our own tokens and components with accessibility built in. Here is how we took it from 90 to 100.

In depth

Design systems in practice

A design system brings together components, design tokens and the rules for using them. It lets a business build more products faster, meet accessibility requirements and keep technical debt down for years.

Many design systems never get further than Figma. The library looks good, but the code in production follows its own rules, and the gap between the two grows every month. We treat a design system as a technical product. The same senior developers who create the visual language also build the components, the pipeline that keeps design and code in sync, and the governance model that keeps the system in use five years from now.

What is a design system?

A design system is a collection of reusable components, guidelines and tools. It lets you build large digital products quickly while keeping the look consistent.

A style guide is static documentation, and a component library is only code. A design system ties the parts together with fixed routines for governance and maintenance. A complete design system usually consists of:

  • Design tokens: the smallest values, such as colours, spacing, typography, shadows and animation.
  • Components: ready-coded building blocks such as buttons, form fields, dialogs and navigation.
  • Patterns: documented approaches to common tasks such as sign-in, error handling and tables.
  • Governance: rules for how the system is developed, maintained and distributed.

Norway has good examples in Aksel from NAV, the Norwegian Labour and Welfare Administration, and in the design system of the Norwegian Tax Administration. They show how the public sector can manage shared digital assets.

What do you get from a design system?

A good design system is more about speed, quality and risk than about looks:

  • The same experience everywhere: users see the same brand whatever the product, platform or team.
  • Faster development: reusable components shorten the path from design to production.
  • Easier maintenance: a change is made in one place and reaches every product, so updates become predictable.
  • Better collaboration: designers and developers share a vocabulary and have fewer misunderstandings.
  • Consistent quality as you grow: when the team gets bigger, the system keeps quality up without anyone becoming a bottleneck.
  • Accessibility built in: WCAG testing happens in the components, and product teams get it for free.

When do you need a design system?

A design system pays off when several teams or products need to look and behave the same way. Typical signs are the same button existing in five variants, designers drawing screens that each developer builds differently, or every new feature starting with rebuilding the same form fields.

If you have one product and a small team, a full design system with its own governance model is often too much. A set of tokens, the most important components and a short guide to using them is enough. It can grow into a design system later, when you need one. Building too big too early is a common mistake, and we'll tell you if that's where you are.

Digdir's Designsystemet or your own?

Norwegian public bodies can use Designsystemet from Digdir, the Norwegian Digitalisation Agency. It's a shared, open design system with components and tokens for Figma, CSS and React. The idea is that you build on it and add your own visual identity on top.

For many public services it's a good starting point. In that case we help you adopt it, create your theme and build the components that are missing. Private companies with a strong brand, or products with very specific needs, usually get more from a system of their own. The question we ask is how much of the interface is specific to you, and how much is ordinary forms, tables and dialogs.

Design tokens as the single source of truth

Design tokens are the foundation of a design system. They separate design decisions from the individual platforms.

Instead of writing a colour code such as #0056b3 straight into an iOS app or a React component, we store the value in a platform-independent format (JSON), as defined by the W3C Design Tokens Community Group. Tokens are named after what they're used for, such as primary colour or error colour, so you can change a value without hunting down every place it's used. It also lets you run dark mode or several brands in one codebase: you swap the values behind the names, and the components stay the same.

Automating the step from Figma to code

We set up a pipeline that removes the manual work between design and code:

  1. Definition: designers change a colour or a font in Figma using Tokens Studio.
  2. Versioning: the change is pushed to the repository as a JSON file.
  3. Transformation: a CI/CD pipeline, often using Style Dictionary, turns the JSON file into the formats developers need: CSS custom properties for the web, XML for Android and Swift for iOS.
  4. Distribution: the new values are published automatically as a new version of an npm package.

That keeps design and code in sync. If the brand colour changes, nobody has to search through thousands of lines of code. You change the token, and every application gets the change the next time it updates the package.

Headless components

To get both flexibility and accessibility, we often build on headless components. Instead of writing the logic for keyboard navigation and screen readers from scratch, we use libraries such as Radix UI or React Aria. They provide the behaviour without the styling.

  • Correct behaviour from the start: arrow-key navigation in dropdowns, proper focus management and screen reader support are in place from the first version.
  • Complete freedom over styling: we add our own CSS with Tailwind or CSS Modules, so the components follow your brand exactly. We don't have to override the default styles of a framework such as Bootstrap.

We build the components in React and TypeScript and favour composition over long lists of options. That makes them easier to use correctly and harder to use wrongly.

Accessibility built into the components

The European Accessibility Act (EAA) raises the bar for accessibility, including for private companies. Your design system is the most important tool you have for meeting it.

We work on the principle of compliance inheritance. It's inefficient for every product team to check whether the contrast on a button is good enough or whether a form field has the right aria-label.

  • Tested in one place: we test the components against WCAG 2.2 AA in the design system, with screen readers such as NVDA and VoiceOver, with the keyboard and with automated tools.
  • Quality that carries through: when a team imports <Button /> from the system, all of that testing comes with it. When the rules change, as they did with WCAG 2.2, we update the component in one place, and every application using it gets the update.

This lowers the risk of breaching the regulations, and developers can spend their time on business logic instead of WCAG details. Components alone don't make a product accessible, though. Headings, text and the order of the content also have to be right, and we check those when the system is put into use. Read more about accessibility and how we help with accessibility statements.

Governance and documentation

Building version 1.0 of a design system is the easy part. The hard part is looking after it for years. Without a clear governance model, the system either dies out or splinters into variants nobody recognises. We help you choose a model based on your team structure and maturity:

  • Centralised model: a dedicated team owns the system and builds, tests and distributes everything. It suits organisations where control and consistency matter most, such as banking and finance. The risk is that the team becomes a bottleneck for the product teams.
  • Federated model: representatives from the product teams meet regularly, make decisions and contribute code. It suits organisations where technical skills are spread across teams. The risk is inconsistency and slow decisions.
  • Hybrid model: a small core team looks after the infrastructure and documentation, and the product teams contribute components through a defined contribution process.

We recommend the hybrid model for most Norwegian organisations. It gives people across the organisation a sense of ownership, while the core team looks after quality.

A design system is also worth little if nobody knows how to use it. For most people in the organisation, the documentation is the part of the system they actually see. We set up living documentation with Storybook for developers and Zeroheight for designers and product managers. Developers can try out components in the browser, change props and copy the code. For each component we document what it is, when to use it and how, with examples of right and wrong use.

Designed and built by the same people

A common problem with design systems is the handover. Someone makes a library in Figma, someone else builds it in code, and small undocumented decisions get made along the way. Six months later there are two systems that almost look alike.

With us, the same people design and build. Everyone has more than ten years of experience, and you won't get juniors on the project. The person who decides how a dialog should behave also writes the code for it, and knows what's expensive to build and hard to maintain. We keep the quality up with fixed routines:

  • Storybook: every component has its variants and states in Storybook, where they can be tested and compared.
  • Accessibility: automated tests plus manual testing with keyboard and screen reader before a component is marked as stable.
  • Versioning: changes get a version number and a changelog with Changesets, so product teams know what's changed and can upgrade at their own pace.
  • Code review: another senior developer reads the code before it's published.

What does it cost, and what do you save?

Our hourly rate starts at NOK 1,500, and work with a clear scope, such as an audit or a set of core components, gets a fixed price. The price depends mostly on three things: how many platforms the system has to cover, how many components you need, and how much of what you have today needs tidying up. After the audit you get an estimate, so you know what you're getting before we start.

The savings are easy to work out. If you have 20 developers who each spend two hours a week rebuilding a button, fixing a modal or adjusting colours, that's 40 hours a week. That adds up to roughly one full-time position.

A design system removes much of that work, and teams can spend the time on features customers notice.

How we build or clean up a design system

Many organisations already have a half-finished design system, such as a Figma library that doesn't match the code, or components only one team uses. Starting over is rarely the right call. Tokens and governance are often what's missing, while many of the components can be reused after some tidying up. We follow the same method whether we're building something new or cleaning up what you have:

  1. Technical and visual audit: we map where things stand. How many shades of blue do you have? How many button styles are in production? This is the basis for the clean-up, and you get a list of what to keep, what to merge and what's missing.
  2. Tokens: we define the visual language with meaningful names and set up the technical infrastructure for distributing it.
  3. Component architecture: we build the core components with current React patterns and headless libraries.
  4. Pilot: we test the system in a real project to confirm that it solves the problems the teams actually have.
  5. Rollout and training: we roll the system out to the rest of the organisation, run workshops for developers and designers, and put the governance model into practice.

We combine the design system with UX design and service design, so the system supports the whole user experience from start to finish. You own the code and the Figma files we make, and they can live in your own accounts if you want.

Our tools

These are the tools we use in most of the design systems we build:

  • Design and tokens: Figma with variables and Auto Layout, Tokens Studio, Style Dictionary and the W3C Design Tokens format.
  • Components: React with TypeScript, Radix UI and React Aria, Tailwind CSS, and Storybook for documentation and testing.
  • Infrastructure: GitHub Actions for CI/CD, npm or a monorepo for distribution, Changesets for versioning and Zeroheight for documentation shared across disciplines.

Not sure where to start with your design system? Book a chat and we’ll go through it together.

How we work

Book a call
  1. component inventory

    Audit

    We map colours, components and patterns in Figma and in production and find what needs tidying.

  2. tokens and pipeline

    Tokens and infrastructure

    We define the visual language as tokens and set up the pipeline that distributes them.

  3. pilot on a real project

    Core components and pilot

    We build the most important components and test the system in a real project.

  4. workshops and governance model

    Rollout and training

    We roll out to the rest of the organisation, run workshops and put the governance model into practice.

Frequently asked questions

What is a design system?

A design system is a collection of reusable components, design tokens, guidelines and tools, with fixed routines for governance and maintenance. It lets several teams build products that look and behave the same without doing the same work several times.

What is the difference between a design system and a component library?

A component library is only code: ready-made UI elements. A design system ties the components together with design tokens, documentation and a governance model, and that’s what gets the components used consistently and kept up to date.

What are design tokens?

Design tokens are the smallest values in a design system, such as colours, typography, spacing and shadows, stored in a platform-independent format (JSON). A pipeline turns them into CSS, Swift, XML and other formats, so a colour change in Figma reaches every platform.

How does a design system help with accessibility?

We build accessibility into every component: contrast, ARIA attributes, keyboard navigation and screen reader support. Product teams that use the components inherit this quality. When requirements change, we fix the component in one place and every product gets the update.

Should we use Digdir’s Designsystemet?

For many Norwegian public services it is a good starting point, and we help you adopt it with your own visual identity. If you have a strong brand or products with needs of their own, your own system is often the better choice.

Which governance model do you recommend?

For most Norwegian organisations we recommend a hybrid model. A small core team looks after the infrastructure and documentation, while product teams contribute components through a defined process. That spreads ownership across the organisation without slowing everyone down.

Can you clean up a design system we already have?

Yes. We start with an audit of what you have today, in Figma and in production, and suggest what to keep, what to merge and what is missing.

Which tools do you use?

Figma with Tokens Studio for design, Style Dictionary to transform tokens, React with TypeScript and Radix UI for components, Storybook for developer documentation and Zeroheight for cross-disciplinary documentation. Everything is distributed as NPM packages or in a monorepo.

What does a design system cost?

Our hourly rate starts at NOK 1,500. Audits and other work with a clear scope get a fixed price, and you get an estimate before we start. The price depends mostly on the number of platforms, the number of components and how much needs tidying up.

More specialist areas

Want to bring your design into one system?

Tell us where you are today. We’ll go through what you need and work out whether to build from scratch or clean up what you have.