esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

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.

13 min readFree

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.

Key words

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

    Design

    Note who draws, which design tool they use, and how many versions they make. Ask where the work is saved.

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

    QA

    Note who checks the built screen against the design and how they report problems.

  8. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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?

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?

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

How is this lesson?

Last updated on 17 November 2026

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.