Contact Us
Contact Us
UX & Product Design

Design Systems for Growing Teams: When to Build a Design System and How Small to Start

A design system pays off once inconsistent UI starts slowing releases. How to tell when you need one, and how to start with tokens and five components.

JRC Software Team
7 min read
Design Systems for Growing Teams: When to Build a Design System and How Small to Start

Most teams don't need a big design system. They need about five components and a file of named colours, built properly and used everywhere.

The trouble usually starts around the second or third squad. Buttons drift into five shades of blue, every new screen needs a fresh mock-up, and someone builds the third date picker in the codebase because they didn't know the other two existed. Releases slow down and the product starts to feel stitched together.

A design system fixes that, but the phrase scares people. They picture a year-long programme, a dedicated team and a documentation site nobody opens. That version exists, and for most growing product teams it's the wrong place to start. What follows is how to tell whether you need one yet, and the smallest version that actually improves UI consistency.

What you actually get for the effort

Nielsen Norman Group defines a design system as a complete set of standards for managing design at scale using reusable components and patterns. It usually includes a style guide, a component library and a pattern library, plus the people who maintain them. The payoffs NN/g lists are practical: faster design from premade parts, a shared vocabulary across disciplines, visual consistency, and easier onboarding.

Consistency is a usability issue as much as a brand one. NN/g's fourth heuristic, consistency and standards, says users shouldn't have to wonder whether different words, situations or actions mean the same thing. Each inconsistent pattern adds a bit of effort to every session.

Starting small has also got easier. Figma variables store reusable values, switch between modes such as light and dark, and Figma describes them as a way to implement design tokens. And on 28 October 2025 the W3C Design Tokens Community Group announced the first stable version (2025.10) of its specification, a vendor-neutral format for moving design decisions between tools and code.

Signs it's time (and signs it isn't)

Not every team needs one yet. NN/g notes that design systems pay off when an organisation expects years of repeatable design work, and that a prototype likely to change probably won't justify a full system.

SignalWhat it suggests
One designer, one product, still finding product-market fitToo early. Keep a simple shared Figma library and move fast.
Several designers or squads working on the same productStart with tokens and core components now.
The same component built differently in different parts of the codebaseYou're already paying for not having a system.
Web and mobile apps that should feel like one productShared tokens stop the two drifting apart.
A rebrand, dark mode or white-label version on the roadmapTokens turn a large redesign into a smaller configuration change.
New designers or developers take weeks to learn "how we do things"Documented components shorten onboarding.

A quick test: grep your front end for hex colour values. If you find dozens of slightly different greys, you have a design system already, just an undocumented and inconsistent one.

Starting a design system with tokens and five components

The minimum useful version has two layers: the decisions (tokens) and the building blocks that use them (components). Everything else can wait.

Step 1: name your design decisions as tokens

Tokens are named values for colours, type sizes, spacing, radii and shadows. Name them by purpose, not appearance. color.action.primary survives a rebrand. blue-500 doesn't.

A short first list:

  1. Colour: brand, text, background, border, and status colours (success, warning, error, information).
  2. Typography: font families, a type scale of five or six sizes, and line heights.
  3. Spacing: one scale from a single unit, such as multiples of 4 or 8 pixels.
  4. Radius and elevation: two or three values each.
  5. Modes: light and dark if you need them, set up as Figma variable modes.

Keep tokens in one source of truth that both design and code read. The DTCG announcement says one token file can generate platform code for iOS, Android, web and Flutter, and the Design Tokens Community Group lists tools including Figma, Penpot, Sketch, Style Dictionary and Tokens Studio. A common setup is a JSON token file in the repo, transformed by Style Dictionary into CSS custom properties and platform files as part of the build. Two tiers help: primitive tokens hold raw values, and semantic tokens like color.text.error point at them. Components only use the semantic tier.

Step 2: build five components, in Figma and code together

Pick the components that show up on almost every screen. For most products these five cover a large share of the interface:

  1. Button, with primary, secondary and destructive variants, and every state (hover, focus, disabled, loading).
  2. Text input, with label, help text, error message and disabled state.
  3. Select or dropdown, including keyboard behaviour.
  4. Card or container, the basic surface most content sits on.
  5. Modal or dialog, including focus handling and close behaviour.

Build each one in Figma and in code at the same time, with matching names and properties. A component that exists only in Figma is a drawing. One that exists only in code drifts from the design within weeks.

Get accessibility right here, once. Focus states, colour contrast and target sizes are far cheaper to fix in one shared button than across a hundred screens. Our guide to WCAG 2.2 basics lists what to check.

Step 3: write one page per component and agree a rule

Docs can start as one page per component: what it's for, when not to use it, its variants and a code snippet. Then agree one rule: new UI uses system components, and if the component you need doesn't exist, propose it rather than building a one-off.

NN/g says a system needs people to maintain it, at minimum an interaction designer, a visual designer and a developer. In a growing team that can be part of existing roles, as long as one named person is accountable.

Mistakes that sink small systems

  • Building 40 components before any product team uses them.
  • Naming tokens after colours instead of purposes.
  • Letting the Figma library and the code library be owned by different people who never talk.
  • Running the system as a side project with no owner.
  • Forking a big public system and customising it so heavily you can't take updates.

NN/g notes that adopting an existing system is usually the cheapest and fastest option, but heavy customisation can wipe out that saving. Decide early whether you're adopting or building.

How JRC Software gets you started

In week one, our UX and product design team audits what you already have. We inventory components across screens and code, list the duplicates (the three date pickers usually turn up), and pull the tokens hiding in your stylesheets. That audit normally makes the first five components obvious.

Then we set up tokens and components in Figma and in your front-end framework together, wire the token transform into your build, and pair with your developers so they can extend the system without us. At the end you have a token file in the repo, five documented components in both Figma and code, and a written contribution rule. Our designers and engineers work as one team across Melbourne and Sri Lanka, so the Figma file and the code library stay in step from the first sprint.

A common early mistake is to buy a documentation platform before you have ten components worth documenting.

A small system also speeds up later work, such as fixing onboarding flows or adding AI features with consistent patterns. If inconsistent UI is slowing your team down, request a design system review. We'll tell you straight whether you need one yet, and where to start.

Frequently asked questions

What is a design system?

A design system is a shared set of standards, reusable components and patterns that a product team uses to design and build interfaces consistently. It typically includes design tokens such as colours and spacing, a component library in both the design tool and code, and short documentation on when to use each piece. Its job is to make consistent UI the easiest option.

How do I build a Figma design system?

Start by creating variables for your tokens: colours, spacing, type sizes and radii, with light and dark modes if you need them. Build a small set of components, such as button, input, select, card and dialog, that use those variables. Publish them as a shared library, keep names identical to your code components, and add short usage notes to each.

How small can a design system start?

A useful first version can be a set of design tokens and five core components that appear on most screens, built in both Figma and code. That's enough to improve UI consistency and speed up delivery. Add components only when a real product need appears, and don't build a large library before any team is using it.

When is it too early for a design system?

If you have one designer and a product that changes direction every few weeks, a full design system is usually premature. Nielsen Norman Group notes the payoff comes when you expect years of repeatable design work. At that early stage, a simple shared library with consistent colours and type is enough.

UX & Product Design

Request a design system review

Tell us where you're stuck and we'll come back with practical next steps.

Get in touch

Sources