Book a call

WritingBuilding a systemPart 1 of 3 in Building one

How to build a design system: a step-by-step plan for the first 12 months

Most guides start with colours and end with components. The systems that last start with a sponsor, a scope and a pilot. Seven steps in order, a 12-month plan, and the mistakes that sink most first attempts.

On this pageBefore you start: sponsor, scope and owner
  1. Before you start: sponsor, scope and owner
  2. The plan at a glance
  3. Step 1: Audit what you already have
  4. Step 2: Set foundations and turn them into tokens
  5. Step 3: Choose your first components
  6. Step 4: Build in design and code together, with a pilot
  7. Step 5: Document as you go
  8. Step 6: Agree how decisions and requests work
  9. Step 7: Launch, measure and scale
  10. A 12-month plan
  11. Common mistakes
  12. The short version
  13. Frequently asked questions
  14. Further reading

The short answer

To build a design system: (1) get a sponsor, engineering commitment and a named owner; (2) audit what you already have; (3) turn your foundations into design tokens; (4) build the ten most-used components in design and code, inside a real product project; (5) document them; (6) agree how decisions and requests work; (7) launch to more teams, measure, and only then scale to themes, brands and platforms.

  • Fund it in stages. Each stage ends with a "gate" that earns the next round of investment.
  • Build components with a pilot team that needs them, never in isolation.
  • Start with the boring components: buttons, fields, alerts and dialogs. That's where the waste is.

Most "how to build a design system" guides start with colour palettes and end with a component list. That's the visible part of the work, and it's not where design systems fail. In audits, the systems that struggle almost never struggle because the buttons were badly drawn. They struggle because engineering never adopted them, because nobody owned them after launch, or because the team built for a year before anyone used anything.

So this guide puts the people, scope and gates around each step. It's the plan we'd follow ourselves for a growing product company, condensed from our design systems playbook.

Before you start: sponsor, scope and owner

Three things need to be true before any design work starts. Skip them and the rest of this guide won't save you.

A SPONSOR

Someone with a budget

A head of design, product or engineering who will defend the system in planning when a product deadline wants its people back.

ENGINEERING COMMITMENT

A yes from engineering leads

An explicit agreement that teams will use the shared component package. Without it, you're building a UI kit.

AN OWNER

Protected time, in writing

A named designer and engineer, with time reserved in their team's plan. "A bit of everyone's time" becomes nobody's.

Then decide the scope: which stage you're aiming for next, not the final one. If you're not sure whether you need a full system yet, start with do you need a design system?

Watch out

The most common failure we see is a system built by design and ignored by engineering. Staff the work with at least as much engineering time as design time. Adoption happens in code.

The plan at a glance

Here's the sequence, with how long each step usually takes and the gate that should be met before moving on.

Audit2 weeksGate: leadership agrees on the top problems
→
Foundations & tokens1–2 months, part-timeGate: a team ships using only tokens
→
10 core components2–3 monthsGate: the pilot team is measurably faster
→
Docs, releases, contributionongoingGate: a second team adopts without help
→
Scalethemes, platforms, governanceGate: a real change needs it
Fund the system one step at a time and let each step earn the next. Practitioner view

Step 1: Audit what you already have

Before you design anything, find out what exists. An audit (also called an interface inventory) means screenshotting and grouping every button, input, message, colour and text style across your product, then counting the duplicates in design and code.

It does three jobs at once. It shows you where to start. It gives you "before" numbers to prove progress later. And, done as a team exercise, it turns sceptics into supporters: people who find seven different primary buttons themselves rarely need convincing.

Border greys11
Primary button7
Text field5
Error / alert message4
Date picker3
Dialog3
Table2
Different versions found in production in a typical audit. Illustration The shape is what matters: the most common components have the most versions, because they're built most often by the most people.

We've written the full method, step by step, in how to run a design system audit.

Step 2: Set foundations and turn them into tokens

Foundations are the decisions every component depends on: colour, typography, spacing, layout grid, radius and elevation. Settle them before components, because every component inherits them, good or bad.

  • Colour: build ramps with even lightness steps (we use OKLCH), then name colours by their job: text.primary, border.default, action.primary. Check every text and background pairing against WCAG contrast.
  • Typography: a small set of text styles named by role (display, heading, body, label, caption), not by size.
  • Spacing: a scale on a 4px base (4, 8, 12, 16, 24, 32, 48…) so every gap is a choice from a short list.
  • Layout: breakpoints, columns and gutters that match how your product is actually used.

Then store them as design tokens, in one source that feeds both Figma variables and code. This is the cheapest layer of a design system and it pays back first: a rebrand, a dark theme or an accessibility fix becomes a change to token values rather than a hunt through the codebase.

In practice

At CARS24, one blue lived in the code as five different values. A new OKLCH palette and a four-layer token system carried the rebrand across 10+ products in three countries, with a 65% faster design-to-development handoff. Read the case study.

Step 3: Choose your first components

Don't start with the component that's most fun to design, or the one that seems like the biggest problem. Start with the ones that are used everywhere and inconsistent today. Plot each component from your audit on two axes:

more trouble ↑
Plan nextPainful but rare: date picker, file upload. Build after the basics, with the team that needs it most.
Build firstUsed everywhere and inconsistent: button, text field, select, alert, dialog.
Leave aloneRare and fine. One-off widgets stay local until a second team needs them.
Quick tidyUsed everywhere but mostly fine: links, badges, avatars. Formalise, don't redesign.
used more often →
Rank components by how often they're used and how much trouble they cause today. Most teams' first ten land top right, and they're almost always the boring ones.

A typical first set of eight: button, text field, select, checkbox, radio, switch, link and alert. Then containers and feedback (dialog, card, tabs, toast, menu, empty state), then data and navigation (table, pagination, badge, tag, side navigation), and only then the hard ones like date pickers and advanced tables.

A mistake we see often

A team decides to start with the data table "because it's the biggest problem". Six months later they have a sophisticated table, nothing else, and product teams have stopped waiting. Start with components you can finish in days, so teams see progress early.

Build, borrow or buy?

You don't need to build every component from scratch. Our usual recommendation: build simple components yourself (buttons, badges, cards), because they're easy and you'll want full control. Use a headless library (one that handles behaviour and accessibility but has no visual style) for complex interactive components like menus, dialogs, comboboxes and date pickers, because the behaviour is the hard part.

ApproachGood forWatch out for
Build your ownFull control, exactly your needs, no outside dependencySlowest; accessible behaviour for complex components is hard
Headless library + your tokensCorrect, accessible behaviour out of the box, with your own lookYou depend on the library's updates and conventions
Fully styled library, themedFastest start; early-stage products and internal toolsHard to make truly yours; heavy theming can be harder than building

Step 4: Build in design and code together, with a pilot

Every component should be built inside a real product project: a pilot team that needs it for something they're shipping. Dan Mall makes this point in Design That Scales, and in our experience it's the single biggest predictor of a system people actually use. The pilot gives you real requirements, a real deadline and a team that already trusts the result.

For each component, design and code are built as twins: the same name, the same variants, the same options in Figma and in code. Before a component is called "ready", it should pass a definition of done like this:

  • Every state designed: default, hover, focus, pressed, disabled, loading, error.
  • Uses only semantic tokens, no hard-coded values.
  • Works with a keyboard and a screen reader; contrast checked.
  • Same name, variants and props in Figma and code.
  • Tested in the pilot product, with real content (long labels, empty data, translations).
  • Documented: what it's for, when not to use it, and a code example.

At CARS24 this is how the LEGO component system was built: the first components were picked from teams' actual roadmaps, look and feel was tested on real screens, and the result was 44 composable components adopted in India, the UAE and Australia. See how.

Step 5: Document as you go

Documentation decides adoption. A component nobody can find, or can't work out how to use, doesn't exist. Write the page for each component as you build it, while the decisions are fresh, using one template so every page reads the same way: what it is, when to use it and when not to, anatomy, variants, states, accessibility notes, content guidance and code.

Keep everything in one place, a single source of truth, rather than half in Figma descriptions and half in a wiki. We've written a full guide with a component page template in design system documentation: what to include.

Step 6: Agree how decisions and requests work

As soon as a second team starts using the system, you'll get requests: a new variant, a missing component, a bug. Decide now how they're handled, before the first argument:

Who decides what

A short decision-rights table: who has the final say on tokens, components, patterns and breaking changes. One decider per row. See governance.

One front door for requests

A single form that creates an item in a public tracker, plus a weekly triage. See the contribution model.

Versioning rules

Semantic versioning (major.minor.patch), with breaking changes announced ahead and a deprecation period.

Release notes

A predictable rhythm (every two weeks is common) with notes written for the people who use the system, not for the team that built it.

Step 7: Launch, measure and scale

There's no big-bang launch. The system spreads team by team: the pilot, then a second team, then a third, each with less hand-holding than the one before. Set up the rhythms that keep it healthy (office hours, triage, releases, a monthly health check) and start measuring adoption from the first release. See how to measure design system success.

Only once most new work uses the system should you invest in the expensive layers: dark mode and multiple themes, multiple brands, native platforms and formal cross-department governance. These multiply value when the basics are adopted, and multiply cost when they're not.

A 12-month plan

Here's a realistic first year for a mid-sized product company starting from a UI kit or a few shared components. Four workstreams run side by side, and each quarter ends with a gate.

Q1 · StartQ2 · ProveQ3 · SpreadQ4 · Settle
FoundationsAudit. Colour, type, spacing and layout as tokens. Token pipeline.Semantic tokens complete. Contrast checks automated.Dark mode as a second theme.Density modes. Token audit.
Components8 basics: button, field, select, checkbox, radio, switch, link, alert.Dialog, card, tabs, toast, menu, empty state.Table, pagination, badge, tag, side menu.The hard ones: date picker, search, advanced table.
OperationsOwner named. Who-decides-what agreed. Versioning rules.Request and contribution process live. Docs template.First outside contribution. Monthly health check.Deprecate old components. Next year's roadmap.
AdoptionPilot team: a new settings page.Second pilot. A champion in each team.Second and third teams adopt. Office hours.Migration dashboard. Most new work on the system.
GateThe pilot ships using only tokens.The pilot team is measurably faster or has fewer UI bugs.A team adopts without hand-holding.Adoption trend and savings reported to leadership.
A first year in four quarters. Illustration Every quarter delivers something teams can use immediately, so the system earns trust as it goes.

How many people does it take?

For a mid-sized SaaS company (2–3 products, 6–12 designers, 40–80 engineers), a realistic first year is about 45 FTE-months: a part-time lead, one system designer, two engineers during the build, then one and a half engineers plus product-team contributions to run it. A startup can do a lighter version in about 6–7 FTE-months. The full model is in design system ROI and cost.

Common mistakes

How it failsThe antidote
Built by design, ignored by engineeringGet engineering commitment before you start; staff the team with engineers.
Treated as a project, then abandonedRun it as a product, with a team that stays after launch.
Started with the fun componentsRank by frequency and pain; start with the boring ones.
Built in isolation, then "launched"Build every component inside a pilot product project.
Colours named by appearance, not jobSemantic tokens: text.primary, not grey-700.
No way in for requestsOne front door, a public queue and weekly triage.
Docs written last, or neverA page per component, written while it's built.
Measuring output, not useTrack adoption, request turnaround and satisfaction, not components shipped.

The short version

  • Start with a sponsor, engineering commitment and an owner with protected time.
  • Audit first; tokens second; then the ten most-used components, in design and code, inside a pilot.
  • Document as you build, and agree decision rights and a request process before the second team arrives.
  • Fund it in stages with gates. Scale to themes, brands and platforms only once the basics are adopted.

Frequently asked questions

How long does it take to build a design system?

A useful first version, with tokens and 8–15 core components in design and code, usually takes three to six months. A system that most new work runs on takes about a year. After that it's never "done": it's maintained like any product.

Should design or code come first?

Neither: they should move together. Foundations are decided in design and stored as tokens that code reads; components are built as twins with the same names and options on both sides.

How many people do you need?

For a startup, a designer and an engineer with about a day a week each. For a mid-sized company, a small team of two to four. For an enterprise, eight or more, including engineers for each platform. See team structure.

Which components should you build first?

The ones used everywhere and inconsistent today: usually button, text field, select, checkbox, radio, switch, link and alert. Rank them from your audit by frequency and pain.

Should you start from an open-source design system?

Often, yes, for the component layer. A headless library gives you accessible behaviour; your own tokens give you your look. You still need your own documentation, patterns and process.

Further reading