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.

Ticketing: Record, Sort, and Track Every Design System Request

Learn how a design system team turns each request, bug, and idea into one trackable ticket, moves it through a workflow, and closes the loop with the person who asked.

In short

Ticketing turns each design system request, bug and idea into one trackable ticket that moves through a workflow and closes the loop with the person who asked.

13 min readFree

Start Here: What You Will Learn

This lesson teaches ticketing the way a design system team uses it. Ticketing means writing down every request, bug, and improvement, sorting it, and following it until it ends. Each item becomes one trackable record, called a ticket. By the end, you will know what a strong ticket contains, how a ticket moves from first report to done, and how a team keeps the habit healthy.

Why does this matter? A design system is shared by many product teams. Those teams will report broken parts, ask for new ones, and suggest changes. If those asks live only in a chat thread or in someone's memory, they quietly disappear. A ticket keeps each ask visible until someone closes it.

Key words

Ticket
One tracked item that records a single request, bug, or improvement. Many tools also call it an issue.
Request
An ask from a person who uses the system, such as a new part or a change to an existing one.
Bug
Something that is broken or behaves in a way it should not.
Component
One reusable part of the system, such as a Button or a Modal.
Version
The numbered release of the system you were using when you saw the problem.
Template
A preset form with headings that the person filing a ticket fills in.
Triage
The first sorting step, where a team member reviews a new ticket and decides what happens to it.
Label
A short tag on a ticket that shows its type, priority, or team.
Status
The current stage of a ticket, such as In progress or Done.
Reporter
The person who files the ticket.
Assignee
The person who owns the next action on a ticket.
Reproduce
Make a problem happen again by following the same steps.
Contrast
How clearly text stands out from its background. Low contrast makes text hard to read.
Figma
The design tool many teams use to draw screens and the parts of their system.

What does ticketing do for a design system?

Ticketing has one job: make sure every request has a record, a place in line, and a clear end. It helps the team in three ways, and it helps the people who ask for changes too.

  • Nothing gets lost

    A written ticket stays in place after a chat message scrolls away. Anyone can open it later and read its full history.

  • Work is visible

    The team can see how many items are open, which ones are urgent, and who owns each one, without asking around.

  • Requesters know the result

    The person who asked hears what happened: accepted, scheduled, fixed, or declined with a reason.

Tip

A ticket records the request, while chat only starts it. When a request arrives in chat, ask the person to file a ticket, or file one for them and link back to the chat message.

What does a good design system ticket contain?

A good ticket answers the questions a busy team member would ask first. What is affected? What goes wrong or what is missing? What should happen instead?

  • A clear title

    Name the part and the problem in one short line, such as 'Button: disabled text fails contrast.' A title like 'Button is broken' forces the triager to ask questions before anything can start.

  • The type

    Choose one kind. A bug is something broken. A new component request asks for a part that does not exist yet. An enhancement improves something that already exists. A question asks for an answer rather than a change. Many forms show these as a dropdown.

  • The affected component and version

    Name the part and the release where you saw the problem. Without a version, nobody can tell whether the problem is already fixed.

  • Steps to reproduce, or the problem to solve

    For a bug, list the steps that make it happen again. For a request, describe the problem the new part would solve, not only the part itself.

  • The expected outcome

    Say what should happen and set it beside what actually happens. Two short lines make the gap easy to see.

  • Evidence

    Add a screenshot and a link to the Figma frame or the code where the problem shows. Links let the triager see the same thing you saw.

Software teams often use this same shape for bug reports: a title, the environment, the steps, the expected result, the actual result, and a severity rating that shows how much harm the problem causes. The design system version adds the component and version, because a design system problem often spreads to every product that uses the part.

Why use a template so every ticket has the parts?

A template is a preset form. When someone opens a new ticket, the form shows the headings to fill in, so nobody has to remember them. On GitHub, a repository can offer a chooser, so the filer picks a bug form or a feature form before typing.

Some fields should be required. A version field that refuses vague answers such as 'latest' keeps reports useful, because a problem you cannot tie to a version is hard to close. Required fields make the filer answer the questions the triager would ask anyway.

Tip

Keep templates short. Long forms make people delete sections. Read real tickets every month or so, and remove any question that nobody answers.

How does a ticket move through the workflow?

A workflow is the set of stages a ticket passes through, from the moment it is filed to the moment it is finished. Teams name the stages in their own way, but most use the five steps below.

  1. 1

    Intake

    The ticket is filed through a template and lands in one shared place. It gets a label such as needs-triage, so everyone knows it is waiting for a first look.

  2. 2

    Triage

    A team member reads the ticket, confirms that it is valid, adds labels, sets priority, and assigns an owner. If the request is not valid, they reject it and say why. This step gets its own section below.

  3. 3

    In progress

    The owner starts the work and the status changes to show it. If the owner needs more details first, the status moves to a waiting state such as Pending Info instead.

  4. 4

    Review

    Someone other than the owner checks the finished change before it is accepted. The ticket shows that it is waiting on this check.

  5. 5

    Done

    The change is accepted and the ticket closes. The closing note links to the fix, and the reporter learns the result.

How do statuses and labels make the state obvious?

Statuses and labels do different jobs. A status says where the ticket is right now. A label says what kind of ticket it is, how urgent it is, or which team owns it. Together, they let anyone scan a list and understand each ticket in seconds.

  • Status

    The current stage, such as In progress, In review, Pending info, or Done. Keep the list of statuses short so people never have to guess what one means.

  • Type labels

    Tags such as bug, enhancement, feature request, or question. A type label lets a filter show only the bugs, for example.

  • Priority and team labels

    Tags that show urgency or ownership, such as a high priority tag or a team name. Use a small, fixed set.

The requester should be able to read the state from the ticket alone. A status such as Pending Info tells them that the next move is theirs, which saves a chat message asking what is happening.

Triage: Where Each Ticket Gets Sorted

Triage is the sorting step, and it decides whether work happens at all. Before a ticket moves on, the triager usually checks a few things. Is this really a design system issue, or is it a feature wish, a usage question, or a problem in someone else's tool? Can the problem be made to happen again? If not, the triager asks for exact steps, the environment, and any data involved.

Then the triager makes one of these decisions.

  • Confirm

    The ticket is valid. The triager records that decision in the ticket so the reason is kept.

  • Label

    The triager adds type, priority, and team tags so the ticket can be filtered later.

  • Prioritize

    The triager ranks the ticket by its effect on users.

  • Assign or reject

    The triager gives the ticket an owner, or rejects it with a clear reason and a pointer to the right place. A request that belongs to a product team's own code can be sent back with a note that explains why.

  • Ask for more

    If details are missing, the triager posts a short list of questions, a few at most, and sets the status to waiting for the reporter.

Some teams review new tickets in a short weekly session and write each decision in a triage log. Either way, the decision belongs in the ticket, so the next person can see what was decided and why.

Quick check

A product designer files a ticket that says 'Dropdown text is hard to read in dark mode.' There is no screenshot, no version, and no steps. What should the triager do first?

Worked Example: A Button Contrast Bug

Here is one full path through the workflow. A product designer is building a checkout screen with the design system's Button. She notices that the disabled state, the look that tells people a button cannot be pressed right now, has text that is too faint against its background. That is a contrast problem. She files a bug in the design system's GitHub Issues, the shared place where the team tracks its tickets.

  1. 1

    Check the problem

    She reproduces it. She opens the Button on a test page, switches on the disabled state, and confirms that the text is hard to see. She takes a screenshot and notes that the version is 2.3.

  2. 2

    Pick the template

    GitHub shows the available templates. She chooses the bug form instead of starting from a blank page, so the form lists the parts she must fill in.

  3. 3

    Fill the fields

    Title: 'Button: disabled state text fails contrast.' Component: Button. Version: 2.3. Steps: the exact steps she followed. Expected: the disabled text should meet the contrast level that the team's accessibility rules set, and she writes that expected contrast ratio into the ticket. Actual: the ratio she measured. Evidence: the screenshot and a link to the Figma frame.

  4. 4

    Intake

    The template adds a default needs-triage label, so the ticket shows up in the queue for a first look.

  5. 5

    Triage

    A maintainer reproduces the problem, confirms that it is a bug, adds the accessibility and high priority labels, and assigns an owner. The accessibility label lets the team find all similar work later.

  6. 6

    In progress and review

    The owner moves the status to In progress. When the fix is ready, it goes to review, and the ticket links to the change so anyone can follow it.

  7. 7

    Done

    When the fix is accepted, the ticket closes with a link to the fix. The designer reads the result in the ticket thread, and she knows the problem will not come back unnoticed.

Tip

The high priority label only helps when the team agrees what it means. Write the rule down, such as which user harms count as high, so the next filer knows when to use it.

Ticketing as a Healthy Habit

A tracker works only when people use it the same way each time. These five habits keep ticketing healthy.

  • Use issue templates

    Give each kind of request its own form. The form does the reminding, so filers do not have to remember what to write.

  • Use one shared place

    Send every request to the same tracker. Chat threads, emails, and private notes all lead to lost work. A shared board also lets people see the whole queue at once.

  • Set consistent labels and priority rules

    Write down what each label and priority level means. Review the list now and then, and remove tags that nobody uses. Priority is only useful when everyone applies it the same way.

  • Respond quickly

    Reply within the time your team agrees on, even if the reply is only that the ticket is in the queue. A quick reply tells the reporter that the request was read.

  • Close the loop

    Tell the reporter when a ticket is resolved, declined, or waiting on them. A ticket that stays open in silence feels lost, even when someone did work on it.

Good tracking tools also reduce the chores. Some boards let a team member see tickets in columns by status. Some automations move a ticket when a related change is opened or merged. These features help, but they cannot replace clear rules that people follow.

Close the Loop With Every Requester

Closing the loop means the requester always learns the outcome. Most tickets end in one of four ways: fixed and linked, accepted and scheduled, declined with a reason, or waiting for information from the reporter. A declined ticket should give the reason and point to a better place when one exists. For example, a design system team that gets a request for a feature that belongs to a product team can point the requester to that team.

Tip

Check tickets that sit in a waiting status, such as Pending Info, on a set schedule. If nobody answers after a fixed time, close the ticket with a short note. That keeps the open list honest.

Check Your Understanding

Try this scenario. It uses the ideas from the whole lesson, not only one sentence of it.

Quick check

A developer posts in the team chat: 'The Modal close icon looks off on mobile.' Two weeks later, nobody remembers it. What should have happened with this request, and what should the ticket include?

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.