On this page
To work out how to create a design system for a small team, skip the big library. Start with an audit of what you already have, then ship a first release small enough for one person to look after.
This guide is for a startup product team of one to three designers, with a template you can copy and a token file you can test. If you would rather have senior help with the work, our SaaS design services cover the system along with the product it serves.
What is a design system?
A design system is the shared set of decisions and parts a product team reuses: design tokens, coded components and the rules for using them. A Figma library alone is only part of one, because it stops before the code.
Brad Frost's book Atomic Design (2016) gives a useful model: atoms, molecules, organisms, templates and pages. Frost calls it a mental model rather than a linear process, so use it to think about parts and wholes.
Scope varies widely. Figma's design systems guide places systems on a spectrum, from simple component collections for small teams to comprehensive systems for enterprise organizations. A startup belongs at the simple end.
How to create a design system in six steps
Six steps take you from what exists to what you need. Each one narrows the next, which keeps the first release small.
- Audit what exists. Capture your screens and list what the code already reuses.
- Agree on principles. Write three short rules that settle an argument between two designs.
- Define tokens. Name your colour, type, spacing and radius decisions in a file that design and code can both read.
- Build the most-used components. Make or adapt six, in design and in code, with every state.
- Document usage. Say when to use each component and when not to.
- Name an owner and a release process. One person decides, and changes ship as numbered releases.
You can move most of this order. Figma's guide admits that principles often emerge later in the work, and that is fine as long as everyone knows them once they exist. The audit is the one step you should never move or skip.
Adapt a system or start from scratch?
Adapt an existing framework, unless your product has an interface no framework covers, such as a dense data tool. That is our advice for a one to three designer team. If you adapt, the six components become your framework's versions, themed with your tokens, and the state and documentation work still applies.
Asking how to create a design system from scratch assumes a custom build, but Figma's guide names two routes: a custom system, or an existing framework adapted to your needs. It says the first takes more time and resources upfront, while the second can get you moving faster and may need more customization.
Before you decide, read how mature public systems work. IBM's Carbon is open source, and the U.S. Web Design System explains why it limits its tokens to a small set of discrete options. Copy the thinking, and leave their size behind.
What makes a good design principle?
A good principle settles a trade-off between two reasonable designs. "Be clear" settles nothing, because nobody argues for confusion. Figma's guide asks for a small set of memorable, actionable statements, and our template starts with three.
Here are two invented examples for a SaaS product. "Clarity over density" means you remove a table column before you shrink the text. "Defaults over settings" means you ship one good default before you add an option. Test each rule on your last design argument: if it would not have ended that argument, rewrite it.
A design system template for a 1-3 designer team
A sensible first system has 18 items across five layers: 3 principles, 4 token groups, 6 components, 3 documents and 2 governance rules. Patterns wait. These counts are our working rule of thumb, and no published standard sets them, so copy this design system template and let your audit adjust it.
| Layer | Make first | Minimum | Skip for now |
|---|---|---|---|
| Principles | Rules for trade-offs | 3 principles | A brand manifesto |
| Tokens | Colour, type, spacing, radius | 4 token groups | Themes you do not ship |
| Components | Most-used parts from the audit | 6 components | Rare one-offs |
| Patterns | Nothing yet | None until a flow repeats | A pattern library |
| Documentation | Setup, usage, changelog | 3 documents | A separate docs site |
| Governance | An owner, a release rule | 2 rules | Committees and forms |
Patterns are the reason this list looks short. A pattern is a reusable answer to a whole flow, such as sign-up or filtering a table. Early products change those flows often, so a pattern written today may describe something you remove next quarter. Add your first one when the same flow appears in two parts of the product and works well in both.
Start with an audit, not a blank file
An audit shows what your product already repeats, so the system records real decisions instead of inventing new ones. It also makes the case for the work, because it puts a number on the duplicates nobody chose.
Figma's guide suggests gathering examples across platforms and devices, including interactive states, and then inventorying the codebase too. The second part matters most at a startup, because engineers may already have reusable components that no design file mentions.
A spreadsheet is enough. List every category (colours, font sizes, spacing values, buttons, inputs), then record each variant, how often it appears and where. Say your audit finds 23 greys, 9 font sizes and 4 button styles. That invented example gives you a clear job: keep the variants used most, unless they fail accessibility, and replace the rest.
The same pass often turns up problems that consistency cannot fix, such as flows that confuse people. Our UX audit checklist covers those, and our UI UX audit services help when you want an outside review before you build anything new.
Define design tokens before you build components
Design tokens are named design decisions, such as a colour or a spacing step, stored in a format that tools and code can both read. Define them first, because every component depends on them and renaming them later is expensive.
The format to know is the Design Tokens Format Module from the Design Tokens Community Group (DTCG). As of October 2026, its stable version is 2025.10, published on 28 October 2025. The World Wide Web Consortium (W3C) hosts the group, but that does not make this a W3C standard: the document says plainly that it is neither a W3C Standard nor on the W3C Standards Track.
Here is a small token file in that format. It holds one raw colour, one alias and one spacing step:
{
"color": {
"$type": "color",
"blue-600": {
"$value": {
"colorSpace": "srgb",
"components": [0.102, 0.329, 0.851],
"hex": "#1a54d9"
}
},
"action": {
"$value": "{color.blue-600}",
"$description": "Primary buttons and links"
}
},
"space": {
"$type": "dimension",
"md": { "$value": { "value": 16, "unit": "px" } }
}
}
Three things are worth copying. The raw value and its purpose are separate, so components use "action" and never "blue-600", and a rebrand changes one line. The curly braces make "action" an alias of another token, and the "$type" sits on the group, so each token inside inherits it. Figma's guide gives the same advice on names: choose ones that reflect function over appearance.
Check your tools before you commit to a format. Style Dictionary exports tokens to CSS, iOS, Android and other platforms, but its DTCG page warns that format 2025.10 does not have full support there yet (as of October 2026). Run a small file through your pipeline first.
In Figma, variables and modes hold tokens and switch them between contexts such as light and dark themes. As of October 2026, Figma's help page on modes lists them on its Education, Professional, Organization and Enterprise plans.
Test colours while they are still just tokens. The Web Content Accessibility Guidelines (WCAG) 2.2, current as of October 2026, ask at level AA for a contrast ratio of at least 4.5:1 for text and 3:1 for large text, and 3:1 for interface components against adjacent colours. The sample blue above reaches about 6.3:1 on white (our calculation), so it passes for text of any size.
Build the few components your product uses most
Build the six components your audit counts most often, in design and in code together. In many SaaS products that means button, text input, select, checkbox, table and modal, but your own numbers should make the final call.
A component is finished when every state exists. Cover default, hover, focus, disabled, error, loading and empty wherever they apply, because missing states are what engineers end up inventing during a build. Storybook describes itself as a frontend workshop for building components and pages in isolation, which makes hard-to-reach states easier to see and share.
Put the accessibility rules into the component, so nobody has to remember them later. WCAG 2.2 requires a visible keyboard focus indicator at level AA (criterion 2.4.7). It also sets a minimum pointer target of 24 by 24 CSS pixels at the same level, with some exceptions (criterion 2.5.8). For a modal or a custom select, follow the W3C's Accessible Rich Internet Applications (ARIA) Authoring Practices Guide, which covers semantics and keyboard support for common widgets.
Document usage, then name an owner and a release process
A component without usage notes gets rebuilt, and a system without an owner drifts. Write three short documents, name one person who decides, and ship changes as numbered releases.
The three documents fit in your code repository:
- Setup. How a designer gets the library and how an engineer installs the package.
- Usage notes. For each component: when to use it, when not to, its states and a code sample.
- Changelog. What changed in each release, and what a team needs to do about it.
The two governance rules are just as short. First, one named person owns the system. That can be part of their job, but the name must be written down.
Second, every change ships as a numbered release using Semantic Versioning: a major version for incompatible changes, a minor version for backward-compatible additions and a patch for backward-compatible fixes. Renaming a token breaks whatever uses it, so that is a major release.
The owner also needs a test for new requests. The GOV.UK Design System contribution criteria ask for evidence that a component would be useful to many teams and that it does not replicate something already there. Before publication, they also ask for user research with a representative sample that includes people with disabilities. At your size, a short round of sessions on a prototype, using these usability testing questions, is a smaller check than that bar, so include someone who uses assistive technology where you can.
When is a design system worth building?
A design system is worth building once more than one person ships interface work and the same parts keep getting rebuilt. Before that, a token file and a shared library do most of the job for a fraction of the upkeep.
One published figure comes from Figma, which sells design tools, so read it with that in mind. In an experiment published in 2019, a Figma data scientist found that designers finished a task 34% faster with a design system than with only old design files to reference. Figma itself says the system was up to date and directly relevant to the task, and it expects this to be the maximum saving in real work. Treat 34% as a ceiling, one that a stale system is unlikely to reach.
Three signs say it is time:
- Two engineers have built the same component in different ways.
- Designers keep redrawing parts that already exist in the product.
- Small visual changes take a pass across many screens.
Wait if you are still testing whether anyone wants the product. Keep tokens, and leave the rest until the core flows stop changing every month.
How we build design systems with product teams
We start with your product: an audit of what exists, then tokens and the components your screens use most, built for your engineers to own. Our SaaS product design page answers the common question of whether we build systems or only screens.
When the same team needs the build as well, our software product development services keep design and code in one plan. Every engagement is under an NDA, and the IP is always yours.
Frequently asked questions
How do you create a design system from scratch?
Start with an audit, even from scratch, because most products already hold decisions worth keeping. Then write a few principles, define colour, type, spacing and radius tokens, and build your most-used components in design and code. Document their usage, name an owner and ship the first version small. Growth should follow real product needs.
What is the difference between a design system and a style guide?
A style guide records how things should look, such as colours, type and tone. A design system includes those rules and adds working parts: tokens that tools can read, coded components and notes on when to use them. A style guide tells people what to do, while a design system also hands them the parts.
How long does it take to create a design system?
There is no reliable standard figure, because scope drives the answer. A token file and a few components is a far smaller job than a full library across several platforms. A better question is what the next release must contain. Ship a small first version, then treat the system as ongoing product work.
Should a startup use an existing design system?
Usually yes, if a framework fits your product. Adapting one can get you moving faster, though it may need customization, and a small team rarely gains much from rebuilding a button. Keep your own tokens on top, so the look stays yours. Build custom parts only where your product needs something the framework lacks.
Are design tokens a W3C standard?
No, not as of October 2026. The Design Tokens Format Module comes from a W3C Community Group, and version 2025.10 is stable, but the document says it is not a W3C Standard or on the Standards Track. It is still intended for implementation, and many design tools take part in the group.
How do you create a design system in Figma?
Set up variables for your tokens, using modes for contexts such as light and dark themes if your plan includes them. Build components that use those variables, name them by function, and share them as a library across files. Map each design element to its code component where one exists, so design and production stay aligned as the system grows.
Who should own a design system in a small team?
One named person, usually a designer or a front-end engineer with time set aside for it. They decide what goes in, keep the changelog and publish releases. Input can come from anyone, but one owner keeps decisions moving. Without that name, requests stall and teams quietly start building their own versions again.
Sources and update history
- Design Tokens Community Group, Design Tokens Format Module 2025.10
- W3C, Web Content Accessibility Guidelines (WCAG) 2.2
- W3C WAI, ARIA Authoring Practices Guide
- Figma, Design system 102: How to build a design system
- Figma, Measuring the value of design systems
- Figma Help Center, Guide to variables in Figma
- Figma Help Center, Modes for variables
- Style Dictionary, home page
- Style Dictionary, Design Tokens Community Group
- Storybook documentation
- Semantic Versioning 2.0.0
- GOV.UK Design System, Contribution criteria
- U.S. Web Design System, Design tokens
- Carbon Design System
Update history
- First published.
