# Making it from Scratch: Building a Design System for a New Product

> How to start a design system when a product has no consistent interface yet: foundations first, small layers next, and a plan to keep it alive.

**In short:** Making a design system from scratch means defining the foundations, components and rules first, without existing screens to learn from, then using them to design the product.

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

## What You Will Learn

Most design systems are built after a product already exists. Teams look at their screens, find the buttons and colors that repeat, and turn them into shared rules. This lesson covers the other case: a product with no consistent interface yet. You build the system from zero, by deciding the rules and parts before a large set of screens exists.

By the end, you will know why foundations come first, how to build in small layers, and how to plan for use and growth. You will also see a worked example from a small budgeting app and answer two short questions.

- **Design system:** A shared set of rules and reusable parts that keep a product looking and behaving the same way across its screens.
- **Foundations:** The base layer of a design system: the principles, look, and basic values that every other part uses.
- **Design token:** A named value that stores one design decision, such as the brand color or the space between items. Think of it as a labeled variable.
- **Component:** A reusable piece of an interface, such as a button, that people copy and reuse instead of drawing again.
- **Pattern:** A set of components put together to solve a common task, such as a sign-up form.
- **Adoption:** How much the people on a team actually use the system in their daily work.

## What Does Building from Zero Mean?

Making a design system from scratch means you define the foundations, components, and rules without an existing set of screens to learn from. You make the decisions first, then use them to design the product. This is common in three cases: a brand-new product, a startup that is about to launch its first app, and a full rebrand where the old look is being replaced.

Starting from zero has a clear benefit. You do not inherit the old mix of colors, sizes, and button styles that grew up over time. The risk is the opposite problem. Teams can build far more than they need before any real screen asks for it. A good starting plan avoids both problems.

> **Tip:** Starting from zero does not mean starting big. Your goal is the smallest set of decisions that lets your team design the first real screens well.

## Why Start with the Foundations?

Foundations are the base that later decisions rest on. If you design components first, each one tends to hide its own choices. One button might use one blue, and another card a slightly different blue. Setting the foundations first gives every later part one place to get its values from.

### Principles and Design Language

Start by writing a few design principles. These are short statements that guide choices, such as clarity over decoration or accessible by default. When a team disagrees about a button or a layout, the principles give them a way to decide.

Next, describe the design language. This is the look, feel, and voice of the product: how it appears and how it talks to people. Write it down before you pick any colors. Other lessons in this course cover design language in depth, so here you only need the basic idea: the language guides the values you choose next.

### Core Tokens: Color, Type, and Spacing

Once the principles and language are clear, define the first design tokens. A token is a named value, such as brand primary for one blue. When the value changes in one place, every part that uses the token changes with it. This is why tokens are the base for the rest of the system.

A first set usually covers three areas: color, typography (the fonts and text sizes), and spacing (the gaps between and inside items). Keep each set small. Many new teams need fewer colors than they expect: one brand color, a secondary color used sparingly, a handful of grays for text and borders, and a few status colors for success, warning, and error. For text, pick one font for headings and one for body text, and make each size look clearly different from the next.

For spacing, many teams use a base-8 system, where every gap is a multiple of 8. Some teams use an 8-pixel spacing step as one example. Some teams also name tokens by their job, such as primary action color, instead of by their raw value. This lets a brand change in one place without rewriting every screen.

> **Tip:** If two text sizes look the same to a user, you only need one of them. Each token should earn its place.

## Why Build in Layers, Smallest First?

After the foundations, build the system in layers. Start with the smallest pieces and add larger ones on top. Each layer is built from the layer below, so the whole system stays connected.

- **Basic elements:** The smallest pieces, such as buttons, text inputs, and icons. They are built from tokens, not from new one-off values.
- **Components:** A basic element or a few elements combined into one reusable part, such as a card that holds a title, some text, and a button.
- **Patterns:** Components put together to solve a common task, such as a sign-up form or a filter bar. Detailed definitions of these terms are in their own lessons.

The rule is that each larger layer should use the smaller ones you already defined. If a new screen needs a special style, that is a sign to check whether the style belongs in a token or a component, instead of being drawn once and forgotten.

### Add Only What the Product Needs

A common mistake is to plan a huge library before the product has any users. Many guides warn against this. A half-finished library that nobody uses does more harm than good, because it takes time to keep up to date. Instead, build the parts the first screens really need.

For a new product, many teams begin with roughly 8 to 12 components they already expect to use, such as buttons, text inputs, selects, checkboxes, cards, modals, navigation, and a list or table. Add others only when a real screen needs them. A useful rule is that the second time you copy an element, it is a candidate for a component. The first time, keep exploring.

1. **List your first screens:** Write down the screens you plan to design first, such as sign-up and the main dashboard.
2. **Mark the repeats:** Find every element that appears on two or more of those screens. These are your first components.
3. **Build them with tokens only:** Make each part from your color, type, and spacing tokens. Do not type a new value by hand.
4. **Stop and check:** Design the screens with only these parts. Add a new component only when a screen truly cannot work without it.

## Plan for Adoption and Growth

A design system only helps when people use it. A system that lives only in a design file, and never reaches the product, is more like a mood board. Plan for use from the first week, and keep the plan light enough that a small team can keep it going.

### Write Brief Guidelines as You Go

Write a short usage note for each part as you build it. Say what it is for, when to use it, when not to use it, and what it is called. A short page of rules can also cover naming, accessibility expectations, and how someone proposes a change. A new team member should be able to read it in about ten minutes and make the same choices you would.

Write these notes while the decisions are fresh. It is much harder to explain a button six months later than to write two lines about it today. Full documentation is covered in its own lesson.

### Why Test on One Small Product First?

Pick one small product or one feature to test the system on. Use the new parts on a real screen, and watch where they break or feel awkward. Then fix the part and try again. This keeps the system grounded in real work instead of theory.

Avoid a separate system project that pauses feature work for weeks. Build the system inside real features, one part at a time, so each part is tested by actual use.

### Who Owns and Updates It?

Every system needs an owner: a person or small group who keeps it up to date and decides on changes. Without one, the system slowly drifts away from the product. A system owned only by designers can also end up as a design file that developers never build with, so include the people who build the product in the decisions.

Decide early who approves a new component, who changes a token, and how often the system is reviewed. The full picture of ownership and decision-making is in its own governance lesson.

> **Tip:** A simple test of success is whether a new team member can build a new screen without asking for help. If they cannot, the guidelines or parts need work.

## Worked Example: A Budgeting App

A two-person team is launching a new budgeting app. They have no screens yet, so they build the system from zero. They use only the parts they need for two screens: sign-up and the main dashboard.

1. **Pick the brand color token:** Choose one brand color and name it as a primary color token. Add a neutral gray for text and borders, and a red for errors.
2. **Pick the type scale:** Choose one font family and a few text sizes for headings, body text, and small labels. Each size should look clearly different from the next.
3. **Set the 8-unit spacing scale:** Use multiples of 8, such as 8, 16, and 24, for every gap and inner padding. Name them so the team knows which gap to use.
4. **Build the button:** Make a primary button and a secondary button, both using only the color, type, and spacing tokens. Write one line on when each type is used.
5. **Build the text input:** Make a field with a label, a box, and an error message. Use the same tokens so it looks like part of the same family as the button.
6. **Build the card:** Make a card that holds a title, a short text line, and a button. Its padding comes from the spacing scale and its colors from the tokens.
7. **Design the sign-up screen:** Use only the button, the input, and the card. If the screen seems to need a new part, ask first whether it is really repeated.
8. **Design the dashboard:** Reuse the same parts for the balance card and the list of expenses. When a new repeat appears, add it as a component and note how to use it.

The result is two screens that look like one product, made with few decisions. The team never planned sixty parts. They planned a few tokens and three parts, then let the real screens show what else was needed.

## Check Your Thinking

**Quick check:** A startup has no designs yet and wants a design system before launching its first app. The lead suggests designing 60 components first. What would you do instead, and what would you define first?

A. Agree and design all 60 components, so no future screen is ever missing a part.
B. Define the principles and the color, type, and spacing tokens first, then build only the components the first screens need, and add more when a real screen calls for them.
C. Skip the system completely and style each screen by hand until the product has real users.
D. Start with the complex charts and data tables, since they are the hardest parts to get right.

**Answer:** B. Foundations come first so every later part has a base. Sixty components are guesses about needs the product does not have yet. Building only what the first screens need keeps the work small, and the system grows as real use shows what is missing.

Here is a second case. A designer on a team with a primary color token needs a button for a new screen. She types a blue code straight into the button instead of using the token. Later, the brand blue changes.

**Quick check:** After the brand blue changes, what happens to the button where the designer typed the code by hand?

A. It updates too, because the blue came from the brand color.
B. It keeps the old blue, so it no longer matches the buttons that use the token.
C. Nothing changes anywhere, because tokens only work in code and not in design files.

**Answer:** B. A hand-typed value sits outside the token, so it does not follow the change. This is why the rule is to build with tokens only. A value typed by hand creates a mismatch that is easy to miss.

## Common Mistakes to Avoid

- **Components before foundations:** Building buttons first freezes hidden choices inside each button. Set the principles and tokens first.
- **Too much before any use:** Building dozens of parts that no screen uses creates maintenance work and no value. Build what the first screens need.
- **A system that never leaves the design file:** If the product does not use the parts, the system does not solve the problem it was made for.
- **No owner:** Without someone responsible for updates, the system slowly stops matching the product.

## Key Takeaways

When a product has no consistent interface yet, build the system from zero, but keep it small. Start with the principles and design language, then define a few tokens for color, type, and spacing. Build the basic elements first, combine them into components, and add patterns only when real screens need them.

Write brief guidelines as you go, test the system on one small product, and name an owner who can approve and update it. A small, used system beats a large, unused one every time.

## Sources

- [Let's Build My App: Design System for Startups (what to build and when)](https://letsbuildmyapp.com/blog/design-system-for-startups)
- [Figma: Design system 101, What is a design system?](https://www.figma.com/blog/design-systems-101-what-is-a-design-system/)
- [Lean Design System: Minimum Viable Design System](https://docs.leandesignsystem.org/tactics/principles/minimum-viable-design-system/)
- [925 Studios: How to Build a Design System From Scratch in 2026](https://www.925studios.co/blog/how-to-build-design-system-from-scratch-2026)
- [Wolfpixel: How to Build a Design System, A Practical Guide](https://www.wolfpixel.agency/blogs/how-to-build-a-design-system)
- [Set Product: Design system foundation, tokens and theming](https://www.setproduct.com/blog/how-to-design-a-ui-kit-foundation)
- [Untitled UI: What is a Design System? Definition, Examples, and How to Build One (2026)](https://www.untitledui.com/blog/what-is-a-design-system)
- [DesignKit: Building a Design System from Scratch, A Practical Guide](https://designkit.tech/blog/building-design-system-from-scratch)
- [The Interactive Studio: How to Create a Design System Step by Step (2026 guide)](https://insights.theinteractive.studio/how-to-create-a-design-system-step-by-step)
- [Paychex UX: Your Design System Isn't a Component Library](https://medium.com/paychex-ux/your-design-system-isnt-a-component-library-9466d02dfb83)
- [Adham Dannaway: How to build a design system](https://www.adhamdannaway.com/blog/design-systems/how-to-build-a-design-system)
- [Medium (bammiecreations): Building Your First Design System, A Practical Starting Guide](https://medium.com/@bammiecreations/building-your-first-design-system-a-practical-starting-guide-8d3a9107868c)
