Build a Design System From Scratch for a Redesign

How to build a design system from scratch for a redesign: tiered tokens, shared component names, docs people read and a handoff workflow that stops brand drift.

Build a Design System From Scratch for a Redesign

Most redesigns do not lose the brand at launch. They lose it six months later, when the fourteenth landing page ships with a slightly different blue, a new button nobody approved and a spacing value someone eyeballed. That drift is what a design system is supposed to prevent.

If you plan to build a design system from scratch alongside a website redesign, the visual style matters less than the plumbing underneath it. That means token architecture, naming, documentation and handoff. Get those right and teams ship pages faster. Get them wrong and you end up with a well-presented Figma file that nobody follows.

Get a token architecture and component library your designers and engineers will actually share.

Plan your design system

Start with an inventory, not a canvas

Before anyone opens Figma, screenshot every distinct pattern on the current site and group the screenshots. Buttons, form fields, cards, heroes, navigation, tables. On an established brand’s website you will usually find several near-identical versions of each, all built at different times by different teams.

The inventory does two jobs. It shows you which components actually need to exist, so you do not design 60 when the site needs 25. It also gives you a defensible scope. That matters when procurement asks why the design system is a line item, a question we cover in our guide to redesign budgeting.

This is also when brand strategy turns into constraints. Which colours carry meaning? What should the type scale say about the company? If those answers do not exist yet, settle them first. Our piece on how brand strategy shapes design explains why.

Token architecture: three tiers, one source of truth

Design tokens are named values for design decisions: colour, type, spacing, radius, elevation and motion duration. The common mistake is a flat list. A token called blue-600 tells an engineer which colour to use, but nothing about where it belongs. A good architecture splits decisions into three tiers.

  • Primitive tokens hold the raw palette and scales: color.blue.600, space.400, font.size.300. They are never used directly in components.
  • Semantic tokens describe purpose: color.text.primary, color.surface.raised, color.border.focus. Each one points at a primitive.
  • Component tokens are optional and narrower: button.primary.background points at a semantic token. Use them only where a component genuinely needs to diverge.

Why bother with the indirection? Because changes then cost little. If the brand team darkens the primary blue for accessibility, you change one primitive reference and every semantic token that uses it updates. Dark mode, a high-contrast theme or a sub-brand works the same way: you remap the semantic layer and leave the components untouched. That pattern is what makes a multi-brand design system possible.

Components should only use semantic tokens. If a component file contains a raw hex value or a primitive like blue-600, the architecture has already started to leak.

Where do the tokens live? In a code repository, as JSON. Not in Figma. Figma variables (with modes for themes) are where designers use tokens, but the repository is the single source of truth. A build tool such as Style Dictionary or Terrazzo then turns that JSON into CSS custom properties, a Tailwind theme, or iOS and Android outputs if the system needs to reach native apps.

Use the standard format. In October 2025 the W3C Design Tokens Community Group released the first stable version of the specification (2025.10). The announcement says more than 10 design tools and open-source projects, including Figma, Penpot and Sketch, already support it or are implementing it. If you write tokens with $value and $type and use aliases in that format, you are not locked into one vendor’s plugin.

What should a component be called?

Name a component for what it does, not how it looks. BlueButton breaks the day the brand changes. Button, with a variant of primary, secondary or ghost, will not. The same goes for PromoCard versus BigImageBox.

The more important rule: Figma and code must use the same vocabulary. If the Figma component is “Card / Feature / Large” and the React component is <Tile type=”hero”>, every handoff needs translating, and translation is where errors creep in. Agree on one name, and make Figma component properties match code props one for one:

  • A Figma property called size with values sm, md and lg becomes a size prop with the same values.
  • Boolean properties such as hasIcon or isDisabled map to boolean props.
  • Interactive states (hover, focus, pressed) live as Figma variants for review, but in code they come from CSS, not props.

Keep the list of variants short. When a component collects more than a handful of boolean switches, it is usually two components pretending to be one. Splitting it early saves months of edge cases.

Documentation people actually open

Most design system documentation fails because it lives somewhere separate and goes stale within a quarter. The fix is to generate as much as possible from the code itself. Storybook, for example, can build a props table straight from component types, so the docs cannot disagree with the implementation.

Every component page needs a few things that cannot be generated automatically. Those are the parts that need writing:

  • Purpose and when not to use it. “Use Tabs for peer content; do not use them for sequential steps” prevents more misuse than any visual spec.
  • Anatomy. The named parts, so design review comments and pull request comments use the same words.
  • Accessibility behaviour. Keyboard interaction, focus order, ARIA roles and which semantic tokens guarantee contrast.
  • Content rules. Character limits for headlines and buttons, because content that runs too long is what breaks layouts in production.

Tools like zeroheight or Supernova can combine Figma frames and live Storybook embeds on one page. That helps when marketing or content teams also need the docs. But a tool does not replace ownership. Somebody has to be accountable for each page.

The handoff workflow that keeps pages moving

“Handoff” suggests a single moment when design passes work over a wall. In a working system it is a loop, and the component in the browser is the thing you approve, not the Figma frame. This is the sequence we recommend for a redesign:

Step seven is where speed comes from. After the first few templates, most new pages are built from existing pieces, and design time goes into content and layout rather than redrawing buttons. It also stops performance drifting: animation timing and image handling are built once, in the component, which matters if you are pairing a rich brand with fast, motion-rich pages.

1

Propose the change in design:

A designer explores the new component or token change in a Figma branch, using only existing variables, and flags any new value it needs.

2

Change tokens in the repository first:

New or changed tokens go into the JSON source through a pull request, with the reason stated, so engineering and design review the decision together.

3

Build and sync automatically:

The token pipeline regenerates CSS and platform outputs, and a sync (through Tokens Studio or the Figma Variables API) brings Figma back into line with the repository.

4

Build the component in isolation:

Engineers build it in Storybook with every variant and state visible, before it goes anywhere near a page template.

5

Review in the browser, not the mockup:

Designers sign off the Storybook build at real breakpoints, with real content and keyboard navigation, since that is what users will get.

6

Release with a version and changelog:

The library ships under semantic versioning, so page teams know whether an update is a safe patch or a breaking change.

7

Assemble pages from released parts:

Page builds use only released components. Anything missing goes back to step one rather than being hand-built inline.

Guardrails against brand drift

Good intentions do not survive deadline pressure. Automated checks do. Three are worth insisting on.

First, linting. A Stylelint rule such as color-no-hex, plus a rule that bans unknown custom properties, fails the build when someone pastes a raw colour. Second, visual regression testing (Chromatic, Percy or Playwright screenshots) on every component story, so an unintended change shows up in review before it reaches production. Third, a published contribution model. Teams need to know how to request a new component, who decides and how quickly, or they will build around the system.

A design system fails quietly. Teams do not reject it. They work around it one exception at a time, until the exceptions outnumber the components.

If you are assessing suppliers, these guardrails make a good test. Ask a prospective partner where the tokens live, how Figma stays in sync, and what stops a developer from hard-coding a colour. A competent team answers with a repository, a pipeline and a lint rule. A team that is only plausible answers with a Figma link.

Your next step: take the inventory screenshots, count the distinct button and colour variants on your current site, and use that number to open the scoping conversation. For more on setting boundaries, see how to scope a redesign.

Frequently Asked Questions

How long does it take to build a design system from scratch?

It depends on how many components the site needs and how many brands or themes the system must support. A redesign usually builds the foundations (tokens, type, grid) and the core components first, then grows the library as templates are designed. Treat it as an ongoing product, not a one-off deliverable.

Should design tokens live in Figma or in code?

The source of truth should be JSON in a code repository, ideally in the W3C Design Tokens Community Group format. Figma variables are where designers use those tokens, kept in sync through a plugin such as Tokens Studio or the Figma Variables API.

What is the difference between primitive and semantic tokens?

Primitive tokens store raw values such as color.blue.600. Semantic tokens describe purpose, such as color.text.primary, and point to a primitive. Components use only semantic tokens, so you can change themes and rebrand by remapping one layer.

Do we need Storybook if we already have Figma?

Figma shows what a component should look like. Storybook shows what it actually does in a browser, with real states, breakpoints and keyboard behaviour. Reviewing and documenting components in Storybook keeps the documentation tied to the shipped code.

How do you stop teams from drifting away from the design system?

Combine automation with governance. Lint rules block raw colour values, visual regression tests catch unintended changes, semantic versioning signals breaking updates, and a published contribution process gives teams a faster route than building around the system.

Build a design system your teams will follow

You now know how tiered tokens, shared component names and a browser-first handoff loop keep a redesign on brand. Moburst Digital Experience designs and engineers that system with you, so new pages ship from approved parts instead of being rebuilt from scratch.

Talk to our design engineers