Skip to content
FREN Book a call
( Design system )

Design system: where to start when you are starting from zero

The question is not whether you need a design system, but what to start with so it is still in use three months from now. Here is the order I follow, and the mistakes that cost the most.

· 3 min read · Design system

Design system: where to start when you are starting from zero

( Key facts )

Start with tokens (color, typography, spacing, radius, duration), then about a dozen components that cover most screens, named the same way in Figma and in code. Documentation and governance come next, built from real screens.

Author
Vladimir Spalaikovitch, Senior UX/UI Designer, Product Designer and Digital Art Director
Published
Updated
Reading
3 min · 701 words

A design system starts with foundations, not components: color, typography, spacing, radius and duration tokens, then about a dozen components that cover most screens, named the same way in Figma and in code. Documentation and governance come next, built from real screens.

Before you start: three questions

  1. Who will keep it alive? A system with no named owner dies within six months. Name someone, even at 20% of their time.
  2. For which team? A system for four people has nothing in common with a system for forty. Size it accordingly.
  3. What product already exists? A system is not built in a vacuum. It starts from an inventory of real screens.

Step 1: the inventory

Before designing a single token, take stock of what exists. Capture every button, every input, every color and every text size used in the product. You will probably find four primary buttons, eleven grays and seven body text sizes.

This inventory serves two purposes: it shows decision-makers the size of the problem, and it gives you the list of components you actually need.

Step 2: tokens

Tokens are the smallest and most stable design decisions. I set them in this order.

Family Content Advice
Primitive color The raw palette: grays, accent, states Few hues, a regular scale
Semantic color Background, surface, text, accent, success, error, warning Components use these, never the primitives
Typography Families, fluid scale, weights, line heights A scale of six to eight sizes is enough
Spacing A 4 or 8 pixel scale Every margin and padding derives from it
Radius, shadows, borders Three radii, three shadows, two borders Beyond that, nobody knows which one to pick
Motion Three durations, two easing curves Motion is a system decision

Semantic tokens are what make dark mode, white labeling or a brand refresh possible without touching the components.

Step 3: the first twelve components

Build them in order of use, each with its variants and states (default, hover, focus, active, disabled, error, loading):

  1. Button
  2. Input
  3. Select
  4. Checkbox and toggle
  5. Table
  6. Card
  7. Navigation
  8. Tabs
  9. Modal
  10. Notification
  11. Badge
  12. Avatar

Resist the temptation to do more. A component joins the system when a need comes up a second time.

Step 4: Figma and code, same names

The gap between the Figma file and the code kills most systems. Agree on a single naming convention and apply it on both sides:

  • Figma variable color/surface/raised equals CSS property --color-surface-raised.
  • Figma component Button with a tone property equals component <Button tone="…">.
  • Text style text/body/md equals token text-body-md.

If the team uses Code Connect or a token layer exported as JSON, automate the link. Otherwise, document it and check it at every review. The topic is covered on the front-end development page.

Step 5: minimal documentation

One page per component, four sections:

  • When to use it.
  • When not to use it, and what to use instead.
  • An example taken from the product.
  • A counter-example taken from the product.

That's it. Documentation is written from real screens, after use. Writing documentation before anyone has used the component produces pages nobody reads.

Step 6: governance

Three rules are enough at the start:

  1. A single channel for component requests and inconsistency reports.
  2. One owner who arbitrates and publishes releases.
  3. An exception rule: a deviation is allowed if it is tracked; if it comes up twice, it becomes a component.

The five most expensive mistakes

  1. Starting with components: everything has to be redone at the first brand change.
  2. Copying a big system (Material, Carbon): it solves other people's problems, not yours.
  3. Trying to cover every case: the system covers the frequent cases and tolerates exceptions.
  4. Documenting before using: documentation serves people who already have the need.
  5. Not naming an owner: see question number one.

A real example

On Climeet, the Figma system was set up in three weeks from the wireframes: tokens, typography, about fifteen components. When the client asked for a simplified version of the calculator, the foundations did not move. Only the screens changed. The same system then powered the marketing website. That is exactly what a design system should make possible.

For hands-on support, see the design system page.

( FAQ · 03 )

Frequently asked questions

Should a design system start with components or with tokens?

With tokens. A component built on hard-coded values has to be rebuilt at the first brand or theme change. Tokens (color, typography, spacing, radius) are the most stable layer and the cheapest one to put in place.

How many components do you need at the start?

About a dozen covers 80% of a product's screens: button, input, select, checkbox and toggle, table, card, navigation, tabs, modal, notification, badge, avatar. Everything else gets added when a real need shows up twice.

Do you need a dedicated documentation tool?

Not at first. One page per component in Figma or Notion, covering when to use it, when not to use it, one example and one counter-example, is enough for six months. Documentation tools come in once the team goes beyond roughly ten contributors.

( Next · 04 )

Keep reading

  1. Design system

    Design system design: tokens, Figma and code components, documentation and governance, for teams that want to ship faster and stay consistent. Let's talk.Design SystemsRead
  2. Front-end development: a designer who codes

    UX/UI designer who codes: realistic prototypes, pixel-perfect HTML, CSS and React front-end development, fast static websites and hands-on developer support.UX/UI designer who codes: realistic prototypes and HTML, CSS and React builds.Design · DevRead
  3. Climeet

    Climeet case study: art direction, a Figma design system and React prototyping for an app that measures the carbon footprint of events, plus its website.Art direction, design system and React prototype for a carbon footprint app.Event tech · Carbon · Design systemRead
  4. B2B SaaS UX: ten principles I learned building my own

    Ten B2B SaaS UX principles learned by co-founding a SaaS company: first value, one action per screen, real data, useful errors, clear pricing, measurement.Ten B2B SaaS UX principles, learned by co-founding a SaaS company. · 3 minRead