Book a call

WritingFundamentalsPart 1 of 3 in Planning the system

Design systems for startups: the minimum that pays off

A startup that copies a tech giant's design system process drowns in it. The minimum viable system that survives every pivot, what not to do yet, and the signals that tell you it's time to add the next piece.

On this pageThe startup that copied a tech giant
  1. The startup that copied a tech giant
  2. The minimum viable design system
  3. What not to do yet
  4. When to add the next piece
  5. How the model grows with the company
  6. The short version
  7. Frequently asked questions
  8. Further reading

The short answer

A startup doesn't need a design system team, a governance council or a custom component library. It needs a minimum viable system: named tokens for colour, type and spacing used in code from day one; a themed off-the-shelf component library (headless or styled); a small Figma library that matches it; one page of "how we build UI"; and two named owners, a designer and an engineer, with about a day a week protected. Add structure only when a real problem appears: teams waiting, decisions stalling or quality slipping.

  • Tokens cost days, survive every pivot and are the foundation everything later builds on.
  • Don't copy how a famous tech company runs its system. Use the lightest model that keeps the system trusted.
  • "Build it locally" is a respectable answer for anything only one team needs.

The startup that copied a tech giant

An illustration

The situation

A 60-person startup reads how a famous tech company runs its design system: a dedicated team, a governance council, a formal request process, quarterly planning. They copy it.

What goes wrong

Two designers spend half their week in process meetings. A button change needs council approval. Product teams wait weeks for simple things and start building their own.

What would have fitted

One owner with protected time, a shared channel, a fortnightly half-hour review, and "build it locally" for anything one team needs. Process grows when the company does, not before.

The rule we use: use the lightest model that keeps the system trusted and moving. Every meeting, approval and form should solve a problem you actually have today.

The minimum viable design system

1Tokens in codeColour, type, spacing and radius as named values, used everywhere. Days of work.
2A themed libraryAn off-the-shelf component library, themed with your tokens. Don't build your own yet.
3A small Figma libraryVariables and the components you actually use, named like the code.
4One page and two owners"How we build UI" in one page; a designer and an engineer with a day a week.
Four steps, in order. Step 1 is the one to get right: tokens survive every pivot, rebrand and rewrite. Practitioner view

1 · Tokens from day one

Name your colours by job (color.action.primary, color.text.muted), set a spacing scale and a type scale, and use only those names in code. It takes days and pays back at every pivot: a rebrand, dark mode or a second product becomes a change of values, not a rewrite. The free palette generator, type scale generator and token generator will get you there in an afternoon.

2 · Borrow components, don't build them

At this stage, product is still changing fast and you can't afford months on a date picker. Use a well-maintained library and theme it with your tokens: a fully styled one for speed, or a headless one if you want your own look with tested behaviour. Wrap it in your own components with your own props from the start, so swapping it later doesn't touch product screens. See build, borrow or buy.

3 · A Figma library that matches

Variables for your tokens, and only the components you actually use, named exactly like the code. Twenty well-kept components beat a downloaded kit of two hundred that doesn't match what engineers ship.

4 · One page, two owners

A single page explaining how you build UI: where tokens live, which library you use, how to add something new. And two named owners, a designer and an engineer, with about a day a week protected. Without names, "everyone owns it" quickly means nobody does.

What not to do yet

DO

Habits, not process

Check whether something exists before building it. Put reusable things in the shared place. Review new UI in your normal design critique. Ask in the team channel.

DON'T, YET

Structure without a problem

A dedicated team, a council, request forms, a docs platform, custom versions of standard components, component tokens, quarterly design system planning.

When to add the next piece

Add structure when a specific problem appears, not on a calendar. These are the signals we watch for:

SignalWhat to add
More than about three squads depend on the shared UIA small dedicated team: a designer and an engineer, at least part-time each
The same component has been built twiceMove it into the shared library (the rule of two)
Teams wait more than a week for small changesA simple request process and a contribution guide
Updates break screensVersioning rules and release notes
New joiners can't find thingsA documentation site and onboarding
A second brand or a mobile app is comingA token pipeline and semantic token layer, if you don't have one
Signals and responses. Practitioner view Each response solves a problem you have; none is worth adding before it appears.

How the model grows with the company

StageTypical sizeModelWhat exists
Early-stage startup10–50 people; 1–3 designersEmbedded: two owners, a day a weekTokens, a themed library, a small Figma library, one page
Scale-up50–300 people; 3–8 squadsSmall central team starting hybrid: 1–3 people plus champions20–35 components, docs site, versioned releases, simple requests
Mid-sized300–2,000 peopleHybrid, written-first: a core team of 4–8Themes, contribution, health metrics, a documentation portal
The first three stages. Illustration Sizes are typical, not rules; the signals above matter more than headcount. More in the operating model and team structure.
A mistake we see often

Hiring one "design system designer" at the scale-up stage and expecting a system. Without engineering capacity, you get a beautiful Figma library and very little real use. The minimum effective team is a designer and an engineer.

The short version

  • Tokens in code from day one; they survive every pivot.
  • Theme an existing component library; wrap it in your own API.
  • A small Figma library named like the code; one page of guidance.
  • Two named owners with protected time.
  • Add structure only when a specific problem appears.

Frequently asked questions

Does a startup need a design system?

It needs the basics: named tokens used in code, a themed component library and a small matching Figma library. It doesn't need a dedicated team or formal process until several squads depend on shared UI.

Should a startup build its own component library?

Usually not. Theme a well-maintained library with your tokens and wrap it in your own components, so you can replace it later without changing product screens.

When should a startup hire a design system team?

When more than about three squads depend on shared UI, or teams are regularly waiting on or duplicating components. Start with a designer and an engineer.

What's the cheapest thing that makes the biggest difference?

Tokens. Naming colours, type and spacing and using only those names in code takes days and makes every later change cheaper.

Further reading