As a product grows, it starts to look and behave like several products: three styles of button, two date pickers, forms that validate differently on each screen. Users notice, and every new feature takes longer to design and build than it should. A design system is the usual cure, but it is not always the right next step.
What a design system is
A design system is the shared foundation a product’s interface is built from. It usually has four parts:
- Design tokens: named values for colour, typography, spacing, radius, shadows and motion (for example
color-text-mutedorspace-4), used by both design files and code. - Components: reusable, coded building blocks such as buttons, inputs, tables, dialogs and navigation, with all their states (hover, focus, disabled, error, loading).
- Patterns: proven combinations for common tasks, such as forms, search and filtering, empty states and onboarding.
- Guidelines and documentation: when to use each component, accessibility requirements, writing style and examples.
The key word is shared. Designers and engineers use the same components, so what is designed is what gets built.
What it is not
A design system is not a one-off UI kit in a design tool, and not a brand style guide. Both are useful, but without coded components and an owner they drift away from the real product within months.
Signs you need one
- Several teams or products share an interface.
- The same component exists in multiple versions across the product.
- Engineers rebuild common UI for each new feature.
- Design reviews keep catching inconsistencies in spacing, colour or behaviour.
- Accessibility is fixed screen by screen instead of once.
- A rebrand or theme change (such as dark mode) looks impossible.
Signs it is too early
- One small team is still searching for product-market fit.
- The interface changes fundamentally every few weeks.
- There is nobody who could own and maintain it.
Even then, start the habits that grow into a design system: define tokens and keep a small library of core components. It costs little and makes the eventual system much easier.
How to start small
- Audit the interface. Screenshot every button, input, colour and text style in use. The duplication usually makes the case on its own.
- Define tokens. Agree a palette with semantic names, a type scale and a spacing scale. Use them in design files and code.
- Build the core components first: buttons, form fields, typography, layout, navigation, dialogs and feedback messages. Cover every state and make them accessible by default.
- Document as you go, with live examples and clear “use this when” guidance.
- Migrate gradually. Replace old components as screens are touched, rather than in one big rewrite.
- Set up ownership and contribution: who decides, how teams request changes, how new components are added and versioned.
What you get back
- Consistency: the product feels like one product, which builds user trust.
- Speed: teams assemble features from tested parts instead of starting from scratch.
- Accessibility: contrast, focus states and keyboard support are solved once in the components.
- Easier change: updating a token or component updates the product everywhere, which makes rebrands and themes realistic.
- Better collaboration: designers and engineers share a vocabulary and a source of truth.
Common pitfalls
- Building a large system before teams use the basics.
- Design files and code drifting apart because they are maintained separately.
- No owner, so the system stops evolving and teams work around it.
- Components that are too rigid to cover real use cases, or so flexible they enforce nothing.
Start with what the product uses most, keep design and code in step, and treat the design system as a product of its own, with users, a roadmap and an owner.