Making a Design System: The Big-Picture Steps From First Audit to Upkeep
A plain-language map of how a team turns scattered design choices into shared, documented parts it can keep up, and how to choose where to start.
In short
Making a design system is a map of steps that turns scattered design choices into shared, documented parts a team can keep up, starting from a first audit.
9 min readFree
What you will learn
This lesson shows the whole path of making a design system. You will see the main phases in order, why a design system should be treated like a product, and how a team chooses where to begin. Later lessons go deep on each step, so here you only need the map.
Key words
- Design system
- A shared set of reusable parts, rules, and written guidance that a team keeps up to date and uses across its products.
- Design decision
- A small choice about a color, a size, a button style, or a word, made while drawing a screen.
- Foundation
- The basic visual rules, such as colors, text sizes, and spacing, that the bigger parts are built from.
- Token
- A named value, such as a specific blue, stored in one place so every part can point to it instead of copying it.
- Component
- One reusable piece of a screen, such as a button, an input box, or a card.
- Pattern
- Several components working together to finish one job, such as a sign-in form.
- Audit
- A careful review of what already exists, so you can see what is repeated, what differs, and what is broken.
- Pilot
- A small trial of the system on one real project, used to find problems before wider use.
- Governance
- The agreed way a team decides who can change the system, how changes are checked, and how new versions are released.
- Adoption
- How many people and screens actually use the system instead of building their own parts.
Why is a design system a product?
Many new designers think of a design system as a one-time project. They make a file, share it, and call it finished. Practical guides describe it differently. A design system has users, the designers and engineers who rely on it, and it needs upkeep as the product changes. That means it should be planned and run like any other product.
A clear goal
Write down the problem the system will solve first. For example, the team may want fewer duplicate buttons or faster screen design. Also decide how you will know it is working, such as fewer copies of the same part.
A named owner
One person or one small team must be responsible for requests, fixes, and updates. If everyone owns it, nobody does, and the system drifts back into a pile of variants.
A small starting scope
Pick a few repeated problems and a small set of parts. Do not try to cover every screen, every platform, and every team at once.
Two more things are needed from the start: a plan for adoption and a plan for maintenance. Adoption means getting people to actually use the parts. Maintenance means keeping the parts correct as the product grows. One guide warns that a system never tested on a real product will not be adopted, so testing early is part of the plan, not an extra.
Tip
Before you open any design tool, write one sentence that starts with 'This system exists so that...'. If you cannot finish it in plain words, the goal is not clear yet.
How do you choose a starting path?
There are two common ways to begin. Both lead through the same phases. What changes is the order of work and how much effort each phase takes. The detailed steps for each path are covered in their own lessons, so here you only need to know which path fits your situation.
Build from scratch for a new product
A new product has few screens and no old decisions to undo. The team can define the foundations first, then build parts as real screens need them. Guides for new teams often advise against building every component up front. A half-finished system that nobody uses is worse than having no system, so keep the first release small and useful.
Extract from existing designs for a live product
A live product already has screens, buttons, and colors, often in several slightly different versions. The team starts with an audit of what exists. Then it picks the best version of each repeated decision and makes that the shared one. Engineers may also have reusable code that the design files never show, so include them in the review.
What are the six phases of building a system?
- 1
Audit what exists
List the buttons, colors, text sizes, spacing values, and form parts across the product. Put them on one canvas. The repeated and conflicting choices become easy to see, and that evidence helps you justify the work.
- 2
Define the foundations
Choose a small set of colors, text sizes, and spacing values. Store them as tokens, with names based on their job, so a change in one place reaches every part.
- 3
Build components and patterns
Start with the parts that appear on most screens. Build each one with its states, such as normal, pressed, disabled, and error. Then combine them into patterns for common jobs.
- 4
Document with usage guidelines
Write down when to use each part, when not to use it, and what content it accepts. Good documentation also covers the foundations, the patterns, and the words the product uses.
- 5
Pilot on a real project
Apply the system to one real screen or flow. Watch where people get stuck, record the gaps, and fix them before the wider rollout.
- 6
Govern and evolve
Agree on how people propose changes, how those changes are reviewed, and how new versions are released.
The phases are an order of work, not a strict line. Teams often loop back. A pilot may reveal a missing state, which sends you back to the components, and that is normal. What matters is that every phase is finished well enough for the next one to rest on.
Tip
Keep a one-page map of the six phases near your desk. When a task feels unclear, find which phase it belongs to and ask what that phase needs to produce.
Worked example: a food-delivery app
This example is illustrative. A small food-delivery team notices that its screens use seven slightly different blues and four button styles. Users see the app as uneven, and designers waste time choosing between near-identical options. Here is how the team applies the phases.
- 1
Audit
The team lists every blue and every button on the screens. The count shows seven blues and four button styles, which is the evidence it needs.
- 2
Define the foundation
The team picks one blue for the main action color and retires the other six. It stores this color as a token named for its job, such as action primary, so the name says what the color is for.
- 3
Build the component
The team defines one primary button and draws every state: normal, pressed, disabled, and loading. The other button styles are replaced over time.
- 4
Document
A short note explains that the primary button is for the most important action on a screen, and that a screen should have only one. It also says when a secondary button is the better choice.
- 5
Pilot
The team tries the button on the checkout screen first, because mistakes there cost the most. Suppose the pilot shows that the disabled state is too faint to read. The team fixes it before going further.
- 6
Roll out and govern
After the pilot, the team updates the rest of the app and records every change to the button in one shared list, so later edits are easy to track.
Tip
Choose a pilot screen where a mistake would hurt the most, and where the team can quickly see whether the change works. A pilot that people use for real is worth more than a perfect demo.
Common mistakes to avoid
Building everything at once
When the scope is the whole product, the work never ends and little ships. Start with the repeated decisions that slow the team down most.
Skipping the pilot
A system that has never been used on a real screen often fails when people try it. A short pilot shows the gaps early.
Having no rules for change
Without a way to propose and review changes, every team adds its own variant. Agree on the process before the system grows.
Leaving engineers out
A system owned only by designers can become a design file that nobody builds in code.
Check your understanding
Quick check
A startup's app has inconsistent buttons and colors across ten screens. The team wants to build a full design system in one go. Which first step and scope would you recommend, and why?
Quick check
A team is designing a brand-new banking app from zero. One designer wants to start with the complex data table and the charts, because they seem like the hardest and most important parts. What should the team do first?
Where to go next
You now have the map: treat the system as a product, pick a starting path, and move through the six phases with a pilot before wider use. Later lessons explain each phase in depth, including how to run an audit, the detailed steps of each starting path, and the foundations and components themselves. Keep this lesson as the overview you return to when a step feels unclear.
Sources
- Better Design: How to create a design system, a practical guide
- DesignKit: Building a Design System from Scratch, A Practical Guide
- Void.ma: Design System, The Complete Guide, 2026 Edition
- Webmobtech: A Step-by-Step Guide to Building a Design System
- Design Systems Collective: Building Your First Design System, A Beginner's Guide for Solo Designers
- Wolfpixel: How to Build a Design System, A Step-by-Step Guide
- Designilo: Design System Governance, Who Owns What
- Magic Patterns: Documenting Your Design System, Best Practices
- Netguru: How to Run a Design System Audit, A Step-by-Step Guide for UX Teams
- Medium (Bammie Creations): Building Your First Design System, A Practical Starting Guide
- Adham Dannaway: How to build a design system
- UXPin: Design Systems, Step-by-Step Guide to Creating Your Own
Last updated on 17 November 2026
Related lessons
- System designHow to Approach System Design: A Repeatable Step-by-Step Process
- Design systemsDesign System Examples: How to Read Real Systems as Models
- Design systemsWhat Is a Design System? A Plain-Language Guide for New Designers
- Design systemsNeed of Design System: Why Teams Build Shared Parts and Rules
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.