# Making it from Existing Design: Turn Real Screens Into One Shared System

> Learn how to build a design system from the screens, styles, and parts a product already uses, then merge the messy versions into one shared set.

**In short:** Making a design system from existing design means building it from the screens, styles and parts a product already uses, and merging the messy versions into one shared set.

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

## What you will learn

Many design systems do not begin on a blank page. Most teams already have a product in use, with screens, colors, buttons, and cards that were built over months or years by different people. This lesson shows how to build a design system from that existing design. You will learn why teams choose this route, the core workflow, and how to roll the result out without breaking the product people already use.

By the end, you should be able to explain the main stages of this route, follow a small example, and answer a planning question about what to fix first.

- **Design system:** A shared set of parts, styles, and rules that a team uses to build its products.
- **UI (user interface):** The screens and controls people see and tap when they use a product.
- **Component:** One reusable piece of the interface, such as a button or a card.
- **Style:** A reusable visual choice, such as a color, a font, or a spacing amount.
- **Inventory:** A complete list of the UI pieces a product uses, collected from its live screens.
- **Consolidate:** To combine several similar versions into one.
- **Variant:** A version of a component made on purpose for a different job, such as a smaller button.
- **State:** The look a component takes in a situation, such as normal, pressed, disabled, or loading.
- **Legacy product:** An older product that is still in use and is hard to change quickly.

## Why start from the product you already have?

Starting from existing design means you look first at what people actually see today. A system drawn on an empty page can look neat but miss the real screens. Starting from the live product keeps the work tied to real use.

- **It reflects real use:** The parts you collect are the ones people already meet. You can see which buttons appear on many screens and which appear on only one, so you build for real needs instead of guesses.
- **It wins support faster:** Showing a team its own screens makes the problem easy to see. One product's color count is a good example: UXPin reported 116 color variables and 62 shades of gray before its system existed. Evidence from your own product makes the case for the work.
- **It avoids a full redesign:** You do not have to throw away every screen. You keep what works, merge the near-copies, and change the rest over time.

This route does take time at the start, because you must study and sort the mess before you build anything. In return, you do not invent parts the product never needed, and people who already use the product can see their own work reflected in the new system.

### When does this route fit best?

> **Tip:** Count your screens before you choose a route. If you have many live screens and several versions of the same part, starting from existing design is usually the better first step. A brand-new product with no screens yet is a different case, covered in the lesson on building from scratch.

## What is the core workflow in four steps?

The route has four core steps. Teams often repeat them as they learn more about the product, so think of them as a loop rather than a single pass.

1. **Inventory the live UI:** Go through the product as it runs today. Capture each unique button, field, card, color, and text style from many screens. At this stage, collect first and judge later. Some teams take screenshots of each element to keep the list easy to compare.
2. **Group similar elements:** Place the captures side by side. Put all buttons together, all cards together, and so on. Seeing the versions in one place shows the differences clearly.
3. **Choose or merge the best versions:** For each group, pick the version that works best and is used most. Merge near-copies into it. Some differences are intentional, such as a red button for a risky action; keep those as named variants.
4. **Define shared styles and components:** Write each chosen part down once, as a shared component or style, with its rules for use. Every team then builds from the same source instead of copying old screens.

### How do you sort the differences?

Not every difference is the same kind of problem. Before you merge anything, decide what each difference is. The three kinds below cover most cases.

- **Accidental differences:** A green that is a few shades off, or padding that is a pixel different, usually came from a quick choice. Merge these into the main version.
- **Purposeful differences:** A button that warns about a risk is different for a reason. Keep it as a named variant so people know when to use it.
- **Gaps:** Sometimes a part is missing, such as a message for an empty list. Write the gap down so it can be designed later, rather than guessed now.

**Quick check:** A team's app uses seven shades of blue for buttons and links across 40 screens. They want a design system but cannot afford a full redesign. What should they do first, and why?

A. Pick a new brand blue and redesign all 40 screens before anything else, so the system starts clean.
B. Inventory every blue on the live screens, group them by use and frequency, and choose a main blue to merge the others into.
C. Turn off all blue links until a single new color is chosen, so no one sees the mixed shades.
D. Name every shade in a detailed color list before looking at a single screen.

**Answer:** B. The team first needs to know which blues exist and which ones matter most. Grouping shows the accidental shades to merge, and a main blue can be chosen without redesigning all 40 screens at once.

## Worked example: a food delivery checkout

Here is the workflow applied to one screen. Imagine a food delivery app whose checkout flow was built by several teams over time. This is an illustrative example that follows the lesson plan, not a report about a real company. The same steps work on any live screen.

1. **Inventory the checkout:** Capture every button on the cart, address, and payment screens. You find five slightly different green buttons. Their greens differ a little, and their corner shapes and text sizes vary too.
2. **Group the buttons and cards:** Put the five green buttons together. Then gather the cards: a delivery address card, a payment card, and an order summary card. Each has its own border, padding, and shadow, so you have three card styles.
3. **Choose and merge:** Check how each button is used. Most of the five are the main action that places the order. Choose the green that appears most often and fits the brand, and merge the main-action copies into it. The plain text-style action becomes a secondary style, not a fifth green. Merge the three card styles into one card that can hold different content.
4. **Define one primary button:** Write the primary button as one component. Define its states: normal, pressed, disabled while the order is being checked, and loading while the payment goes through. Each state is a visible rule that a designer can follow.
5. **Define one card component:** Define the card once, with a default look and a selected look for when a payment method is chosen. If a card needs a special layout, record it as a variant instead of a separate style.

The result is one primary button and one card component, each with clear states. The checkout looks more consistent, and the next team can reuse these parts instead of creating a sixth green. The old versions are not forgotten: each merge should be noted, so anyone can see what was replaced and why.

> **Tip:** Before you ship a merged button, compare it with the old one on a real device. Check that the text still fits, the tap area is still easy to hit, and the disabled look is still clear.

## How do you roll it out without breaking the product?

A live product has people who depend on it. A broken checkout costs real orders, so the rollout should be gradual. Changing everything in one release is the fastest way to cause new problems and lose trust in the system.

1. **Prioritize the most-used elements:** Start with the parts that appear on the most screens and vary the most. Changing a button used everywhere gives more value than polishing a control buried in a rarely visited settings page.
2. **Set a rule for new work:** Ask that every new screen or feature use the shared parts from the start. This stops the mess from growing while older screens still wait to be updated.
3. **Replace old UI as screens change:** Move older screens to the shared parts when someone is already working on them for another reason. This spreads the effort out and avoids a large, risky switch.
4. **Check and adjust:** Test changed screens with real tasks, such as placing an order, before moving on. Fix what breaks, then continue with the next group of parts.

### Keep a record of decisions

A simple record stops the same debate from starting again. Keep it in one shared place that the team can find.

- **The decision:** Write what was chosen, such as the main green for the primary button, and what was merged into it.
- **The reason:** Write why it was chosen, such as it being the most used and closest to the brand.
- **The leftovers:** List the inconsistencies still in the product, which screens have them, and who will handle them later.

> **Tip:** Keep the leftover list honest. A short, accurate list of the old UI still in use is far more useful than a claim that the product is already consistent.

**Quick check:** A product has many older cards with different shadows. The team wants to start its system this month. The home screen is seen by most users and is being redesigned next week. A help page with old cards is rarely visited. Where should the team begin?

A. Fix the help page first, because it is the simplest screen to change.
B. Replace every card in the product in one release, so nothing old is left behind.
C. Use the shared card on the home screen, since it is seen most and is already changing, and note the help page as a leftover.
D. Wait until every screen has been audited before using any shared card at all.

**Answer:** C. The home screen gets the most value with the least disruption, because it is already being changed. The help page can wait, and the team should record it on the leftover list.

## Common mistakes to avoid

These mistakes appear often in teams that start from existing design. Watch for them in your own work and in the reviews you take part in.

- **Merging too much:** Forcing one button to do every job hides important differences. Keep purposeful variants so the system still fits the work.
- **Choosing by habit:** Picking the version someone has always used is not a test. Compare how each version is used and how well it works.
- **Skipping states:** A part that shows only a normal look will fail when it is pressed, disabled, or loading. Define those states before you call a part finished.
- **Trying to fix everything:** A full redesign in one go breaks trust and delays the work. A small, steady set of merges usually lasts longer.

### Summary

Making a design system from existing design means you start with the screens people already use. You collect the live UI, group similar parts, merge the best versions, and define them as shared components and styles with clear states. You roll the change out gradually, starting with the most-used parts, and you keep a record of decisions and leftovers so the work can be checked later.

Other lessons go deeper on related steps. Performing a Visual Audit explains how to run the review step by step. Making it from Scratch covers starting with no prior UI. Token, Color, and Typography cover the naming and value details. Pilot covers testing with a small team, and Stakeholders Involved in Building and Governance cover who takes part in decisions. Documentation explains how to write component docs.

## Sources

- [Think Company: A guide to design systems (inventory and audit steps)](https://www.thinkcompany.com/guides/a-guide-to-design-systems/)
- [Think Company: 7 Steps to a Better Design System (design audit and consolidation)](https://think-company.medium.com/7-steps-to-a-better-design-system-think-company-b55ba3efb699)
- [UXPin: Design Systems Step-by-Step Guide](https://www.uxpin.com/create-design-system-guide)
- [UXPin: Creating A Design System, Creating a UI Inventory](https://www.uxpin.com/create-design-system-guide/create-ui-inventory-for-design-system)
- [Secret Stache: How to build a UI design system](https://www.secretstache.com/blog/ui-design-system/)
- [Oboe: Creating a Design System (Mastering Design Systems course page)](https://oboe.com/learn/mastering-design-systems-a36cl4/creating-a-design-system-3u546x)
- [Product Rocket: Design System 101, building from scratch](https://productrocket.ro/articles/design-system-101/)
- [UX Pilot: 7 Design System Best Practices for UI](https://uxpilot.ai/blogs/design-system-best-practices)
- [Veld Systems: Design Systems for Product Teams](https://veldsystems.com/blog/design-systems-for-product-teams)
- [Netguru: Implementing a Design System in an Existing Product](https://www.netguru.com/blog/design-system-in-existing-product)
- [Design Bootcamp (Medium): Building a design system into an existing legacy product](https://medium.com/design-bootcamp/building-a-design-system-into-an-existing-legacy-product-e498b3ece417)
- [Raymond Luong: Applying Product Thinking Principles to your Design System](https://www.raymondluong.com/blog/applying-product-thinking-principles-to-your-design-system/)
- [Storyblocks Design: Building a Design System, a Case Study](https://www.storyblocks.design/blogposts/building-a-design-system)
- [Toptal: Building and Scaling a Design System in Figma, A Case Study](https://www.toptal.com/designers/design-systems/design-system-case-study)
- [Tamruntsova (Medium): Building a Design System, a Case Study](https://medium.com/@tamruntsova/building-a-design-system-a-case-study-3b131a6085fd)
- [Autentika: Enhancing UX, a design system journey at a media and tech holding](https://autentika.com/projects/wp-design-system-case-study)
- [Designsystemscollective: Building a Design System as a Solo Designer](https://www.designsystemscollective.com/building-a-design-system-as-a-solo-designer-6bdee4350410)
