# Identify Existing Design Process: Map How Your Team Works Today

> Before you build a design system, map how your team designs and ships screens today, then use what you find to shape the system.

**In short:** Identifying the existing design process means mapping how your team designs and ships screens today, then using what you find to shape the design system.

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

## What You Will Learn

A design system is a shared set of parts and rules that a team reuses across its screens and products. Before you build one, you need to know how your team already designs and ships screens. This lesson shows you how to map that current process, gather evidence about it, and turn the problems you find into requirements for the system.

By the end, you should be able to draw a simple map of who does what, which tools they use, and where work is handed over. You should also be able to name the pain points on that map and explain why they matter for the system.

- **Design process:** The steps a team follows to turn an idea into a working screen that real users can use.
- **Current-state map:** A simple diagram or list that shows how work moves today, step by step, before any changes.
- **Handoff:** The moment work passes from one person or team to the next, such as from a designer to a developer.
- **Artifact:** Any file or output that a person makes during the work, such as a mockup, a written spec, or a screenshot.
- **Source of truth:** The one place everyone trusts to hold the latest, correct version of a design.
- **Stakeholder:** A person who has an interest in the product, such as a product manager or a team lead.
- **QA (quality assurance):** The checking step where testers confirm that a built screen works and matches the design.
- **Release:** Sending a finished change to real users.
- **Pain point:** A spot in the work where things are slow, unclear, or repeated again and again.
- **Requirement:** A clear statement of what the design system must do to solve a real problem.

## Why Map the Process Before the System?

Many new designers start by drawing buttons, colors, and cards. That feels like progress, but it skips the real question. What is causing the mess in the first place? A team may have three versions of the same button, not because the designers have poor taste, but because nobody told the second designer that the first version existed.

Design system groups often describe their first step as an audit of what exists. Some guides call this a discovery phase. The goal is the same: look at current work before you decide what to build.

A process map answers three questions. Who does each job? Which tools hold the work? Where does work wait, get lost, or get rebuilt? Your answers tell you what the system must include and how people will actually use it.

## How Do You Map the Process From Start to Finish?

Start at the first request and follow the work all the way to release. Map what happens in a normal week, not the ideal process written in a handbook. The handbook shows what people were told to do. The map shows what they do.

### The Stages to Follow

1. **Request or idea:** Find where work starts. It may be a ticket from a product manager, a complaint from users, or an idea from a designer. Write down who starts it and how it arrives.
2. **Research:** Note what people check about users before they draw anything. This can be interviews, usage numbers, or reviews of similar apps. If nobody checks, write that down too.
3. **Design:** Note who draws, which design tool they use, and how many versions they make. Ask where the work is saved.
4. **Review:** Note who looks at the design and how they give feedback. Is it a meeting, a comment in a file, or a chat message? Note how long the feedback takes.
5. **Developer handoff:** Note how developers receive the design. Is it a shared file, a written spec, a link, a screenshot, or a call?
6. **Build:** Note where developers write the screen and whether they reuse existing parts or create new ones. Also note who decides when a part is new.
7. **QA:** Note who checks the built screen against the design and how they report problems.
8. **Release:** Note how the change reaches users and who approves it. Write down any step that needs a manager or another team to say yes.

### What to Note at Each Stage

- **People:** Write the name of the role, not only the name of a person. Note who does the work, who approves it, and who waits for it. Waiting is important because it shows where time is lost.
- **Tools:** List every app that holds work at that stage. A stage may use a design tool, a chat app, a ticket board, and a shared folder all at once. Many teams are surprised by how many tools they use.
- **Artifacts:** List the files and outputs made at that stage, such as a mockup, a clickable prototype, a written spec, a screenshot, or a test report. Note which artifact is the official one and which are copies.

Draw the map as a simple line of boxes, one box per stage, with the people, tools, and artifacts written under each box. Arrows show how work moves. Where work jumps between tools, draw a warning mark. Those jumps often hide problems.

## Why Gather Evidence, Not Opinions?

A map drawn from memory is only a guess. Check it with evidence before you rely on it. Three kinds of evidence help most: what people tell you, what the files show, and what you see people do.

### Who Should You Talk To?

- **Designers:** Ask how they start a new screen, where they save their work, and how they pass it on. Ask them to show you an example from their last project. Ask which parts they often draw again.
- **Developers:** Ask what they receive, which questions they must ask to build it, and which parts they rebuild from scratch.
- **Product managers and QA:** Ask how requests arrive, who decides when a design is ready, and what bugs come back after release. Testers can show you the most common reasons a screen fails.

Interviews work best when they are planned and short. Good research guides suggest asking people to describe their current process, where efficiency is lost, and what would make a handoff ideal. Ask open questions and let people tell their own story.

> **Tip:** Ask for a recent example, not a general view. Ask, for instance, how the last banner or form was built, from the first request to the release. Real stories show gaps that general answers hide.

### Past Work and What People Actually Do

Look at past projects, shared folders, and design files. Notice how many copies of one screen exist and which copy is the latest. Notice which screens were drawn from scratch and which were built from earlier parts. The files show what happened, even when nobody remembers it.

Then compare the files with what people told you. People often describe the process they were trained to follow. Their files may show a different story. A designer may say that all work lives in one shared library, while the folders show many screens drawn from scratch. Write both versions down. The gap between them is a finding in its own right.

The best evidence comes from watching. Sit beside a designer during a real handoff, or read a chat thread where a developer asks a question about a design. Watch where people hesitate, search for a file, or ask the same question twice. These moments are often the pain points you are looking for.

## How Do You Find Pain Points and Opportunities?

Once the map is drawn and the evidence is in, mark the weak spots. Look for patterns that repeat across projects and people. A single mistake is less useful than a habit that keeps showing up.

### Common Pain Points to Look For

- **Repeated redesign:** The same element, such as a button, a card, or a banner, is drawn again and again by different people. Each new copy is a chance for small differences to creep in.
- **Unclear ownership:** Nobody knows who decides how a shared part should look or work. When no one owns a part, each person changes it a little for their own need.
- **Handoff gaps:** Developers receive a screenshot in a chat message and must guess spacing, colors, or what happens on tap. Guessing creates differences, and fixing them later costs time.
- **No shared source of truth:** Many copies of files exist, and nobody can say which one is current. Without one trusted place, people build from the wrong version.

Also watch for slow review. When feedback arrives days later, through many separate threads, changes pile up and people start working from old versions. Note how long each review takes and where comments end up.

Look at opportunities too. A pain point can point to a chance. If three teams already build the same kind of card in their own way, that card may be a good first shared part. Some guides suggest looking at how often each pattern appears, so you can start with the parts that matter most.

### How Do You Turn Problems Into Requirements?

1. **Write each problem as one sentence:** Describe the problem and attach the evidence. For example: developers rebuild the offer banner by eye because they get screenshots, not a spec.
2. **Group related problems:** Put problems with the same cause together. Several complaints about slow reviews may share one cause, such as no named reviewer.
3. **Ask what the system must do:** For each group, ask what the design system must provide to solve it. The answer is a requirement. Keep it about the need, not the look. For example: designers must be able to find the latest version of a banner in one place.
4. **Rank the requirements:** Rank them by how often the problem happens and how much time it wastes. The top items often make a good starting list for the system.
5. **Check with the people involved:** Show the list to the designers, developers, and product managers you interviewed. Ask whether the list matches what they see. Correct it before you go further.

> **Tip:** A good requirement says what the team needs, not how the system should look. Write the need in plain words, such as a shared spec developers can read, and leave the choice of colors and sizes for later.

Checking visual details, such as colors, type styles, and small differences in components, is a separate task. It belongs to a later lesson on auditing existing screens. For now, stay focused on how work moves through the team.

## Worked Example: An Offer Banner in a Food Delivery App

Take a food delivery app like Swiggy. The app has Android, iOS, and web versions. This walk-through is an illustration of the method. The steps are a made-up example that shows how to trace one piece of work. They are not a record of how Swiggy works inside.

1. **Request:** A product manager asks for a banner that promotes a weekend offer. The request arrives as a ticket with a short note and a rough sketch.
2. **Design:** A designer opens a design file, copies an older banner, changes the text and colors, and shares a link to the mockup.
3. **Review:** Two people leave comments inside the file. A third person asks for a different image in a chat message. Nobody checks the banner against a written spec, and no one is named as the final reviewer.
4. **Developer handoff:** The designer posts a screenshot in a shared chat for the Android, iOS, and web teams. The screenshot shows the look but not the spacing rules, text sizes, or what happens when the banner is tapped.
5. **Build:** Each platform team rebuilds the banner by eye. The Android team uses one corner size, the iOS team uses another, and the web team picks its own text size. Each copy is slightly different.
6. **QA and release:** Testers notice that the banner looks different on each platform. The fixes go back and forth through chat, and the banner reaches users late.

What the map shows: there is no shared spec, no review step with a named owner, and no single trusted version of the banner. Each team rebuilds the banner in its own way. This is a repeated redesign problem, a handoff gap, and a missing source of truth, all in one small piece of work.

The requirements that follow from this map are clear. The team needs one shared banner part that all platforms can use. It needs a written spec that developers can read without guessing. It needs a review step with a named owner. It also needs a clear rule for when a new banner is allowed and when an existing one must be reused.

## Common Mistakes to Avoid

> **Tip:** Map the work people really do, not the work the handbook describes. If you map only the ideal version, you will miss the steps that cause the most trouble.

> **Tip:** Write down problems before you design anything. Starting to draw components during the mapping stage often locks in the same old habits.

> **Tip:** Do not blame one person for a broken step. Most handoff gaps come from how the team is set up, not from one designer or one developer.

## Check Your Understanding

Try these two short scenarios. Each one needs the ideas from this lesson to answer well.

**Quick check:** A startup's designers each keep their own design files, developers receive screenshots over chat, and buttons look slightly different on every page. Before anyone proposes a design system, what should you do first, and which two process problems should you document?

A. Build a full button library in one design file this week, then send the link to the developers.
B. Map the current process from request to release, gather evidence from interviews and files, then document the missing shared source of truth and the screenshot-based handoff gap.
C. Ask one developer to pick the best button color and make that color the standard for every page.
D. Delete the extra design files so that everyone must use one file, then review the buttons again next month.

**Answer:** B. Mapping and gathering evidence come first, so the system fits real work. The two problems to document are the lack of one trusted version of the designs and the handoff that depends on screenshots. The other options skip the mapping, or fix a symptom without finding the cause.

**Quick check:** A product manager says that design review on your team takes a day. When you watch a designer, feedback arrives in three different chat threads and some comments wait two weeks. What should you record on the process map?

A. Trust the product manager's account, because the manager knows the process best, and leave review off the map.
B. Record the gap between what people say and what they do, and list the slow, scattered review as a pain point backed by what you saw.
C. Remove the review stage from the map, since slow review is a people problem and not a process problem.
D. Write a requirement that the design system will change the color of the review button.

**Answer:** B. The right move is to record the difference between the account and the observed work, with evidence. Trusting one account alone, or dropping the stage, would hide the problem. A button color does not solve scattered review.

## Summary

Identify the existing design process before you build a design system. Map each stage from request to release, and note the people, tools, and artifacts at every step. Gather evidence from interviews, past files, and what you see people do, and compare it with what they say.

Then look for repeated patterns: repeated redesign, unclear ownership, handoff gaps, and no shared source of truth. Turn each pattern into a clear requirement that the system must meet. This keeps the design system tied to real work, so it helps the team instead of fighting it.

## Sources

- [Obvious University: How to audit a design system](https://university.obvious.in/product-design/design-system/how-to-audit-a-design-system)
- [Awesomic: How to Run a Design System Audit in 2026](https://www.awesomic.com/blog/design-system-audit)
- [Revue Suite: Audit Your Design Handoff Process for Efficiency](https://revuesuite.com/blog/audit-design-handoff-process)
- [Ensuesoft: Product Design Process, From Problem Discovery to Production](https://www.ensuesoft.com/insights/product-design-process)
- [Eightshapes: Starting a Design System](https://eightshapes.com/articles/starting-a-design-system/)
- [The Design System Guide: Design System Research Interview Questions](https://thedesignsystem.guide/design-system-research-interview-questions)
- [UXPin: Design Handoff Checklist](https://www.uxpin.com/studio/blog/design-handoff-checklist/)
- [Timothy Graf: The Complete Guide to Design-Development Handoff](https://timgraf.com/ux-design/the-complete-guide-to-design-development-handoff-building-a-frictionless-bridge-between-designers-and-developers/)
- [Milan Maheshwari: Setting up the Consumer Design System at Swiggy](https://milanmaheshwari.framer.website/setting-up-the-consumer-design-system-at-swiggy)
- [Wikipedia: Figma](https://en.wikipedia.org/wiki/Figma)
- [ThinkCompany: A guide to design systems](https://www.thinkcompany.com/guides/a-guide-to-design-systems/)
- [Better Design: How to create a design system, a practical guide](https://better-design.com/blog/how-to-create-a-design-system)
