# 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.

From "Design systems", a free course by Venkat R. Murty: https://designervenkat.online/learn/design-systems/making-a-design-system

## 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.

- **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?

A. Design every color and component for all ten screens before anyone uses them, so the system is complete on launch.
B. Audit the ten screens, choose one main color and one primary button with its states, document them, and test them on one important screen before wider rollout.
C. Hire a separate team to build a library of forty components, then ask every product team to switch in a single release.
D. Skip the audit and copy the colors and buttons from a popular public design system straight into the app.

**Answer:** B. A small, well-tested first scope fixes the most visible repeated problems and gives evidence for the next step. Building everything at once, or skipping the audit, ignores the phases that make the system usable.

**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?

A. Start with the data table and charts, because the hardest parts should be solved before the easy ones.
B. Write full documentation for every future part before any color, text size, or spacing value exists.
C. Set the basic colors, text sizes, and spacing first, then build the buttons and inputs most screens use, and add complex parts when a real screen needs them.
D. Wait until the app launches, then copy whatever the launched screens happen to use.

**Answer:** C. New teams should define the foundations first, then build the high-use parts, and grow only when a real screen needs more. Starting with complex parts or waiting for launch skips the foundations the other parts depend on.

## 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](https://better-design.com/blog/how-to-create-a-design-system)
- [DesignKit: Building a Design System from Scratch, A Practical Guide](https://designkit.tech/blog/building-design-system-from-scratch)
- [Void.ma: Design System, The Complete Guide, 2026 Edition](https://void.ma/en/publications/design-system-guide-complet-2024/)
- [Webmobtech: A Step-by-Step Guide to Building a Design System](https://webmobtech.com/blog/how-to-build-a-design-system/)
- [Design Systems Collective: Building Your First Design System, A Beginner's Guide for Solo Designers](https://www.designsystemscollective.com/building-your-first-design-system-a-beginners-guide-for-solo-designers-5c8f0304798a)
- [Wolfpixel: How to Build a Design System, A Step-by-Step Guide](https://www.wolfpixel.agency/blogs/how-to-build-a-design-system)
- [Designilo: Design System Governance, Who Owns What](https://designilo.com/2025/07/10/design-system-governance-who-owns-what-and-how-to-keep-it-working/)
- [Magic Patterns: Documenting Your Design System, Best Practices](https://www.magicpatterns.com/blog/design-system-documentation)
- [Netguru: How to Run a Design System Audit, A Step-by-Step Guide for UX Teams](https://www.netguru.com/blog/design-system-audit)
- [Medium (Bammie Creations): Building Your First Design System, A Practical Starting Guide](https://medium.com/@bammiecreations/building-your-first-design-system-a-practical-starting-guide-8d3a9107868c)
- [Adham Dannaway: How to build a design system](https://www.adhamdannaway.com/blog/design-systems/how-to-build-a-design-system)
- [UXPin: Design Systems, Step-by-Step Guide to Creating Your Own](https://www.uxpin.com/create-design-system-guide)
