What Is A Design System

A steel robotic hand picks a single card labelled 'Button' out of a drawn warehouse of dusty, cobwebbed boxes marked 'Carousel v3', 'Chart 14', 'Mega menu', 'Toggle XL' and 'Wizard' under a sign reading 'Components we might need', beside a drawn phone screen.
Noah Chen
Product & Client Success Manager, ANODA
Published · Updated
12 min read
8 sections

In short

A design system connects shared interface decisions with working code and ownership. Learn how it differs from a UI kit, what belongs in it, and which scope fits your product before choosing an implementation plan or component guide.

In this article
  1. What a design system is, and what it isn’t
  2. Why products need one, in money terms
  3. Signs you need a design system now
  4. Which design system do you actually need?
  5. Public design systems worth studying
  6. What a design system won’t fix
  7. How we approach design systems
  8. Choose the next question, then the next guide

A design system is the shared set of decisions a team uses to design and build its interface. It connects foundations, components, patterns, content and accessibility rules with working code and a way to change them. A UI kit can be one part of it; a library of screens alone is not the system.

The practical question is which decisions your product needs to share. A single-product team may need a small governed foundation. A product that has drifted may need consolidation. Several products and teams may justify a dedicated programme. Choosing the wrong scope is how a useful investment becomes a component warehouse.

This guide explains those distinctions and helps you decide what you need. For the implementation sequence, use the guide to building a design system. For component anatomy, variants, states and contribution rules, use design system components.

What a design system is, and what it isn’t

The simplest way to understand a design system is as a language. Tokens are the alphabet. Components are words. Patterns are sentences. The guidelines are the grammar. And like any language, it only works if the people using it agree on the meaning and actually speak it, in design and in code.

A useful design system usually includes:

  • Foundations. The basic decisions everything else is made of: colour, typography, spacing, sizing, corner radius, elevation and shadows, motion, iconography, grid and layout. These are usually stored as design tokens, named values that design tools and code can both use.
  • Components. Reusable interface building blocks: buttons, inputs, selects, checkboxes, tables, modals, toasts, tabs. Each has defined variants, sizes, states and behaviour.
  • Patterns. Proven ways of combining components to solve a recurring problem: a form with validation, an empty state, a filter bar, a confirmation step, onboarding, error recovery.
  • Content guidelines. How the product talks: voice, tone, terminology, how to write labels, buttons and error messages.
  • Accessibility rules. Contrast, focus, keyboard behaviour, screen-reader labels, target sizes, motion preferences, built into the components rather than bolted on.
  • Documentation. Where to find all of this, when to use what, and what not to do.
  • Code. The implemented components, which is where the system becomes real for users.
  • Governance. Who owns the system, how changes are proposed and approved, how versions are released and old parts retired.
Layered diagram of a design system for the fictional Parcelpath: foundation tokens (colour, type, spacing, radius, elevation, motion) at the base, then components, patterns and content guidelines, with documentation and code on either side and governance underneath.
Illustrative example: foundations, components, patterns and guidelines, held together by documentation, code and governance.

Notice what is missing from that list: size. A design system is not defined by how many components it has. A small product can have a perfectly good design system with a dozen components and a clear set of tokens. A large one can have hundreds of components and still not be a system, because nobody agrees on which to use, and the code does something else.

Design system, UI kit, style guide, pattern library

These terms get mixed up constantly, which is part of why teams buy the wrong thing.

  • A style guide describes the visual brand: logo, colours, typefaces, imagery, tone. It tells you what the brand looks like. It doesn’t tell you how a date picker behaves.
  • A UI kit is a collection of interface components in a design tool. Useful for drawing screens quickly. On its own, it has no code, no rules and no process for change.
  • A component library is a set of implemented components in code. It is where the interface actually runs.
  • A pattern library documents how components combine to solve common problems.
  • A design system connects all of these with shared foundations, documentation and governance, so design and code describe the same thing and change together.

If what you have is a UI kit in a design file and a separate, different set of components in code, you don’t have a design system. You have two dialects of the same language, drifting further apart with every release.

Why products need one, in money terms

The case for a design system is usually made in soft words: consistency, harmony, a unified experience. Those matter. But the real argument is about cost, and it is worth being blunt about it.

Without a system, every new screen reopens decisions that were already made. Which blue? Which spacing? What does an error look like? How does this table sort? Each designer answers slightly differently. Each developer implements slightly differently. The product ends up with nine greys, fourteen button styles and six date pickers, and every one of them has to be maintained, tested and fixed separately.

That shows up as:

  • Slower delivery. Designers and developers rebuild things that already exist, because finding and trusting the existing version takes longer than making a new one.
  • More bugs. Six date pickers means six sets of edge cases, six accessibility audits and six places for the same bug to appear.
  • Inconsistent experience. Users learn a pattern on one screen and find it behaves differently on the next. Every inconsistency is a small tax on their trust.
  • Expensive redesigns. Changing the brand colour means finding it in hundreds of places instead of changing one token.
  • Slow onboarding. New designers and developers take longer to become productive when every decision lives in someone’s head.

A good design system cuts all of that. It makes the obvious choice the easy choice. It lets a team spend its time on what is new about a feature instead of rebuilding the parts that are not.

But the same logic works in reverse. A design system is itself something you build and maintain. Every component in it costs money to design, build, test, document and keep up to date. If it is bigger than the product needs, you have just moved the waste from the product into the system.

Signs you need a design system now

Not every product needs a formal design system on day one. But certain symptoms mean the lack of one is already costing you:

  • Designers ask each other which version of a component is “the right one”, and nobody is sure.
  • Developers rebuild components that already exist somewhere in the codebase, because finding them takes longer.
  • The same bug appears in several places, because the same thing was built several times.
  • Design reviews argue about spacing and colours that should have been decided long ago.
  • New team members take weeks to learn how the interface is supposed to work.
  • A small visual change, like a new brand colour or a rounder corner, turns into a project.
  • Accessibility issues keep coming back in new features after being fixed in old ones.
  • You are about to add a second product, platform or team, and the first one is already inconsistent.

If three or more of these sound familiar, you are paying for a design system already. You just aren’t getting one.

Which design system do you actually need?

Before anyone opens a design tool, decide what kind of system fits the product and the team. There are broadly three situations.

Decision table comparing a small governed foundation, a consolidation of what exists and a full design-system programme by signs, first deliverable, typical scope and the risk of overbuilding.
Illustrative example: three kinds of design system work. Most products need the first or second, not the third.

A small governed foundation. You have one product, one team and an early or growing interface. What you need is a clear set of tokens, the components your product uses today, a few key patterns and a simple rule for adding new ones. This is enough for most startups and many mature single-product companies. It can be built quickly and grow with the product.

Consolidation of what exists. You have a live product, several designers or teams over the years, and an interface that has quietly diverged: many button styles, inconsistent spacing, three kinds of modal, components copied and modified in code. The job here is not to invent a system from scratch. It is to audit what exists, pick the best version of each thing, merge the rest and connect design to code. This is the most common need we see, and the one with the fastest payback.

A full design-system programme. You have several products or platforms, several teams, perhaps several brands, and a roadmap that genuinely requires shared foundations across all of them. Here a larger system with dedicated owners, versioning, contribution processes and documentation is justified. But even here, it should be built from the real products outward, not from a blank page inward.

The risk in all three is the same: overbuilding. A small team that sets up a full programme spends its capacity maintaining the system instead of building the product. A large organisation that treats its system as a side project gets a library nobody trusts. Match the system to the product, the team and the roadmap you actually have.

Public design systems worth studying

Many large organisations publish their design systems, and they are worth reading, not copying. Each was built for a specific set of products, users and constraints, and each teaches something different.

  • Material Design (Google). A complete system covering foundations, components and motion across Android and the web. Useful for how thoroughly it documents states, elevation and theming, and for how it treats colour as a set of roles rather than a list of values.
  • Apple Human Interface Guidelines. Less a component library than a set of principles and platform conventions for iOS, macOS and Apple’s other platforms. Worth reading for how it explains why a pattern exists, not just what it looks like.
  • GOV.UK Design System. Built for public services that everyone has to be able to use. It is unusually strong on content, plain language, forms and accessibility, and on publishing the research behind its patterns.
  • Carbon (IBM). A system for complex enterprise products, strong on data-dense interfaces, tables and governance across many teams.
  • Polaris (Shopify). Shopify’s current web components help merchant-facing apps fit the admin experience. Study the shared component and page patterns for decisions about consistency across an ecosystem.
  • Atlassian Design System. A system shared by several products used by the same people, which makes it a good example of consistency across a product family.

Read them for the decisions and the reasoning: how they name tokens, how they document states, how they write about when not to use a component, how they handle contribution and change. Then ask what your product actually needs.

What you should not do is adopt one wholesale because it looks good. A system designed for a government service, an operating system or an enterprise platform with dozens of teams carries decisions that may be wrong for your product. Borrowing the thinking is cheap. Borrowing somebody else’s constraints is expensive.

What a design system won’t fix

A design system is powerful, and it is often sold as the answer to problems it cannot solve. It is worth being clear about its limits.

It will not fix an unclear product. If nobody has decided what the product is for, who it serves or what the main flows are, a design system will help you build the confusion faster and more consistently. Consistent buttons on a screen that shouldn’t exist are still on a screen that shouldn’t exist.

It will not fix a broken user flow. A beautifully specified form component doesn’t help if the form asks for things the user doesn’t have, at a moment they aren’t ready.

It will not replace product decisions. Which feature matters, what to cut, how to handle an edge case in the business logic: those belong to the product team, not the component library.

It will not fix a team that doesn’t talk. If designers and developers work in separate silos, the system will reflect that, with one version in each.

The order matters. Know what the product needs to do, map the flows, then build a system that makes those flows fast and consistent to design and ship. A design system is a very good kitchen. It doesn’t decide the menu.

How we approach design systems

When we work on a design system, we start from the product, not the library. We audit the interface as it exists, in design and in code, and show where it has diverged and what that costs. We define the foundations and tokens, pick or confirm the component base with the engineering team, and design only the components and patterns the product and its roadmap can justify. We test every component in real screens, with real content and all its states, check accessibility at the foundation and component level, and align the design library with the implemented components and the team’s component workshop so both describe the same system.

The goal is not the biggest library. It is a system the team actually uses, that makes the next feature faster to build and the product more consistent to use, and that can grow as the product grows. Our design systems work covers everything from a small foundation for a single product to consolidating a product that has outgrown its original interface.

In Fusion’s dating-app design, ANODA carried the interface into a documented component library and its states for the client’s development team. That is the practical test: the library belongs to the product’s real screens and gives the next person a clear decision to build from.

For a release sequence and migration plan, use our guide to building a design system; for variants and state specifications, read design system components.

Choose the next question, then the next guide

Use a real product task to decide whether your system exists in practice. Open a form that needs an error state. Can a designer and a developer independently find the same component, terminology and behaviour? Can they explain who owns a change? If the answers differ, the system has a gap even if the design file looks complete.

For an illustrative delivery product, a tracking field might use a semantic border token, an input component, an error pattern and agreed wording for an unknown parcel. The system is the connection between those decisions. The field does not become production-ready because its default state appears in a library.

Once you know which gap matters, choose the appropriate next step:

A useful definition should help a team make that choice. The result to aim for is a shared decision people can find, use and change safely when the product needs it.

Related reading

All articles

See a real UX audit

Enter your email to download the sample. This does not subscribe you to a newsletter or create a project enquiry.