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

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

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

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

A. Assign it to the Dropdown owner right away so the work can start.
B. Set the status to waiting for info and ask for the version, a screenshot, and the steps to see the problem.
C. Close it as won't fix, because the description is too vague to act on.
D. Raise the priority to high so that it gets noticed sooner.

**Answer:** B. Triage checks whether a report is complete enough to act on. Without a version or steps, no owner can reproduce the problem, so the right move is a short, specific request for details. Assigning or raising priority first wastes the owner's time, and closing the ticket drops a real problem.

## 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. **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. **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. **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. **Intake:** The template adds a default needs-triage label, so the ticket shows up in the queue for a first look.
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. **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. **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?

A. Nothing. A chat message is enough if the team saw it, and a quick thumbs-up closes the loop.
B. The developer should file a ticket that names the Modal component, the version, the mobile device and browser, a screenshot, the steps to see the problem, and the expected look. Triage should then label it, assign an owner, and tell the developer the outcome.
C. The team should fix the icon in the code straight away and tell no one, since the fix speaks for itself.
D. The request should wait for the next big release, where the team can review every small change together.

**Answer:** B. A chat message starts a request but does not record it, so it fades. The ticket should keep the component, version, device, screenshot, steps, and expected outcome. Triage should move it through statuses and labels until the developer hears the result.

## Sources

- [GitHub Docs: About issue and pull request templates](https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/about-issue-and-pull-request-templates)
- [GitHub Docs: Creating an issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/creating-an-issue)
- [ONES: Designing a Software Issue Tracker Template That Teams Actually Use](https://ones.com/blog/designing-a-software-issue-tracker-template-that-teams-actually-use/)
- [Plane: Issue tracking workflow, definition, stages, and examples](https://plane.so/blog/issue-tracking-workflow-definition-stages-and-examples)
- [UI Zap: Bug Triage Templates Pack for Lean Teams](https://blog.uizap.com/bug-triage-templates-pack/)
- [MangoApps: Bug Report Triage SOP Template](https://www.mangoapps.com/templates/sop/bug-report-triage-sop)
- [DriveNets design-system pull request 790: request triage routine instructions](https://github.com/drivenets/design-system/pull/790)
- [ONES: Team Task Management With GitHub Issues and Workflows](https://ones.com/blog/team-task-management-with-github-issues-projects-workflows/)
- [ONES: GitHub Task Management Step-by-Step Workflow for Dev Teams](https://ones.com/blog/github-task-management-a-step-by-step-workflow-for-dev-teams/)
- [Everhour: Jira Best Practices, 15 Tips for Better Project Management](https://everhour.com/blog/jira-best-practices/)
- [Jira Alternatives: Jira Project Guide, 7 Steps for Organized Team Workflows](https://jiraalternatives.com/guides/jira-project-guide-7-steps-for-organized-team-workflows)
- [Jira Alternatives: Jira Service Desk Practical Guide to Better Support Teams](https://jiraalternatives.com/guides/jira-service-desk-practical-guide-to-better-support-teams)
- [Everhour: GitHub Templates, Issue, Pull Request, Actions and Pages Templates](https://everhour.com/blog/github-templates/)
- [Scribelet: GitHub issue templates, the fields worth requiring](https://scribelet.app/blog/github-issue-template)
- [Eightshapes: Using Jira for Design Systems](https://medium.com/eightshapes-llc/using-jira-for-design-systems-10ec31c3327e)
- [Zigiwave: How to Organize and Prioritize Jira Issues Effectively](https://zigiwave.com/resources/jira-issue-prioritization-organization)
- [GitHub Docs: Labeling issues and pull requests (GitHub Enterprise)](https://docs.github.com/en/enterprise/2.16/user/github/managing-your-work-on-github/labeling-issues-and-pull-requests)
