# Project Management: Plan, Prioritize, and Track Design System Work

> How a small design system team decides what to build, who owns each piece, and how the work moves from request to done.

**In short:** Project management for a design system is how a small team decides what to build, who owns each piece, and how work moves from request to done.

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

## What You Will Learn

A design system is a shared set of parts, rules, and guidance that many product screens use. Building and caring for it is real work, and that work never really ends. Project management is the habit of planning that work, organizing it, and tracking it. Done well, it lets a small team see what it will ship, who will do it, and in what order.

In this lesson you will learn how to treat a design system like a product with users, a team, and a scope. You will learn how to rank requests, how to say no or later without losing trust, how to set up clear roles, and how to run a simple shared board. A worked example shows each idea in use.

- **Design system:** A shared set of parts, rules, and guidance that teams use to build consistent product screens.
- **Backlog:** One ordered list of all the work people have asked for or the team has noticed needs doing.
- **Prioritize:** To put items in order of importance, so the most valuable ones come first.
- **Scope:** The set of things the system covers now, and the things it does not cover yet.
- **Stakeholder:** Anyone who is affected by the system or can influence it, such as a product manager or a team lead.
- **Effort:** How much time and skill a change will take to design, build, and check.
- **Risk:** What could go wrong with a change, such as breaking many screens or depending on work that is not finished.
- **Owner:** The one person who makes sure an item moves forward and who has the final say on its scope.
- **Board:** A visual layout with columns, where each card is one piece of work that moves from left to right.

## What does project management mean here?

Imagine a team of three people who look after a design system used by a dozen product teams. Requests arrive every day. Each product team says its request is the most urgent. The team has only so many hours in a week, so it cannot do everything at once.

Project management turns that noise into a visible, ranked flow of work. Requests come in, get checked, get ranked, and then move through clear stages until they ship. The point is not to make a perfect plan. The point is that everyone can see the same list and trust that it reflects real choices.

## Why treat the system as a product?

Many teams treat a design system as a side job for whoever has spare time. That usually leads to missed requests, slow fixes, and frustrated users. A better approach is to manage the system the way a company manages a product. A product has users, a team, a scope, and a list of work to prioritize.

The design system team at Workday, which maintains the Canvas system, mapped everyone who was affected by its work. They found that designers and developers were their most valuable users. They then added dedicated product management and engineering help, and set up regular routines such as planning sessions and reviews. Their experience shows that a system needs real people with clear jobs.

### Users, Team, and Scope

Start by naming who uses the system. For most design systems, the main users are designers, who build screens, and developers, who build the parts in code. Other stakeholders, such as product managers, also depend on the system.

Next, name the team. Decide who makes decisions, who builds the work, and who checks quality. Then write down the scope. The scope is the list of what the system covers now and what it will leave out for later. A clear scope protects a small team from taking on everything at once.

> **Tip:** This can help product teams see it as support they rely on, especially when no central team exists yet.

### What is the backlog?

The backlog is the single list of everything the team could do. It holds new components, bug fixes, documentation updates, and cleanup jobs. Because time is limited, the backlog never gets fully finished. Its job is to show the order in which work should happen.

Ideas that are not ready should not clutter the backlog. Many teams keep a separate parking lot, such as a simple shared document, for early thoughts. An idea moves into the backlog only after someone checks that it is clear and useful.

Design time counts too. When designers are already full, adding more requests only makes a hidden queue that the plan does not account for. Include design capacity in every ranking decision.

## How do you prioritize and scope the work?

Prioritizing means choosing what comes first. Scoping means deciding exactly how big a piece of work is and what is inside it. Both steps should use the same rules for every request. Otherwise, the loudest team wins and the quiet team waits forever.

### How do you score every request the same way?

A simple way to rank requests is to score each one against a few shared criteria.

- **User demand:** How many product teams or people need this? A change that five teams need usually beats a change that only one team wants.
- **Product impact:** How much would this help users or the products that rely on the system? Think about what gets easier, faster, or safer.
- **Effort:** How long will the design, the build, and the checks take together? Ask the people who will do the work to estimate it as a group.
- **Risk:** What could go wrong? A change that touches many screens, or that waits on unfinished work, carries more risk and needs more care.

Use simple words such as high, medium, and low rather than false precision. The goal is a fair comparison, not a perfect number. Write the score and the reason next to each request so anyone can read it later.

> **Tip:** Score the request, not the person who asked. Keep the names out of the scoring table so that every request gets judged on the same facts.

### Say No or Later, and Explain Why

Ranking only works if the lower items really wait. Every request should end with one of three answers: now, later, or not now. A later answer should include a rough idea of when the team will look at it again.

1. **Check the request is clear:** Ask what problem the requester is trying to solve. If the answer is vague, ask for one example before scoring.
2. **Score it with the shared criteria:** Use the same four questions you used for every other request.
3. **Choose now, later, or not now:** Compare the score with the work already planned. Be honest about what the team can finish.
4. **Write the reason:** Use one or two plain sentences. For example, the change helps one team while another change helps five.
5. **Tell the requester:** Share the decision in the same place the request arrived. Say what would change the answer.

> **Tip:** Say what would move a request up the list. For example: if three more product teams need this, we will schedule it next. A clear condition feels fairer than a flat no.

## Roles: Who Does What

Work moves faster when everyone knows their job. Good roles describe responsibilities and decision rights, not only job titles.

- **Owner:** The owner decides the order of the item, keeps it moving, and makes the final call on its scope. One item should have exactly one owner.
- **Contributors:** Contributors do the design, build, documentation, and testing. A single item may have several contributors, such as one designer and one developer.
- **Reviewers:** Reviewers check the finished work against the system's rules, accessibility needs, and the needs of the requesting team before it is released.

Some small teams rotate the job of handling new requests each week, so no single person becomes a bottleneck. Others keep one person as the permanent lead for prioritizing and final sign-off. Either choice works, as long as the team writes it down and everyone knows it.

> **Tip:** Never let the same person be both the only contributor and the only reviewer. A second pair of eyes catches mistakes that the builder cannot see.

## A Simple Shared Board

A shared board makes work visible. Each column is a stage, and each card is one piece of work. When someone moves a card, everyone sees the change. This replaces many status meetings and private messages that ask 'where is this at?'

Keep the stages simple. Here is a plain set of stages that fits most small design system teams.

1. **Requested:** A new request has arrived. Nothing has been checked yet.
2. **Scoping:** The owner confirms the problem, scores the request, and names the owner and contributors.
3. **Planned:** The request is ranked as now or later. Its owner, contributors, and reviewer are set, and the item has a clear scope.
4. **In progress:** Contributors are designing or building the change. Questions go back to the owner.
5. **In review:** A reviewer checks the work against the rules and the accessibility needs before it can move on.
6. **Released:** The change is available to product teams, and its documentation is updated. The owner tells the requester it is done.

A separate 'Later' lane can hold the requests you said no or later to. Keeping them visible means they are not forgotten, and the team can see how long they have waited.

> **Tip:** Limit how many cards can sit in the In progress column at once. Fewer active items usually means each item finishes sooner, and the board shows where the team is stuck.

## Worked Example: Three Requests, One Clear Choice

Imagine a team at a company like Shopify. This example is an illustration of the method, not a record of what that team actually did. In one week, three requests arrive: a new date picker, a fix for a tooltip, and an update to support dark mode.

1. **Log all three as Requested:** Each request gets a short description and the name of the product team that asked. No work starts yet.
2. **Score each on demand and effort:** The date picker is needed by five product teams, and its effort is high. The tooltip fix affects one team, and its effort is low. The dark mode update touches many screens, its effort is high, and its risk is high because it depends on shared color rules that are still being settled.
3. **Decide now, later, or not now:** The date picker goes first because five teams need it. The tooltip fix is scheduled next as a small job. The dark mode update moves to Later, with a written reason and a condition: the color rules must be finished first.
4. **Assign the owner and reviewer:** A designer becomes the owner of the date picker. A developer partner is the contributor. A second designer is the reviewer, and the accessibility check is part of the review.
5. **Move the card across the board:** The date picker card moves from Scoping to Planned, then In progress, then In review, and finally Released. Its status is always visible to everyone.
6. **Tell each team what happened:** The team that asked for the tooltip fix hears when it is scheduled. The dark mode team hears why it waits and what would move it up the list.

Notice what the team did not do. It did not start with the loudest request, and it did not promise everything at once. Each decision came from the same criteria, and each team got a clear answer with a reason.

> **Tip:** Public design systems often accept feedback in the open.

## Common Mistakes to Avoid

- **Taking the loudest request first:** Urgency felt by one team is not the same as value for many teams. Score every request with the same criteria.
- **Saying no with no reason:** A silent no makes teams stop sending requests. A short, written reason keeps them engaged.
- **Letting the board go stale:** A board nobody updates shows a false picture. Update the card when a stage changes, even if the change is small.
- **Ignoring design time:** Requests that need more design hours than the team has will sit unfinished. Count design capacity before you promise a date.

## Check Your Understanding

Try these short scenarios. Each one asks you to use the ideas from this lesson.

**Quick check:** Your design system team has three people. In one week, ten component requests arrive from different product teams, and each team says its request is urgent. What should you do first to decide what gets built?

A. Build the request from the team that sent the most messages this week.
B. Pick the easiest request to build and ignore the other nine until next month.
C. Score all ten requests on demand, impact, effort, and risk, then mark each one now, later, or not now.
D. Ask every team to present its case at a meeting, then build whatever the most senior person likes.

**Answer:** C. A fair order comes from the same criteria for every request. Scoring all ten makes the comparison visible, and each team can then hear a clear now, later, or not now with its reason.

Once the order is set, the next question is who does the work and who checks it.

**Quick check:** A designer on a small team owns a new card component, builds it alone, and is also the only person who reviews it. A week later, a product team reports a broken layout. What is the most likely cause?

A. The item had no owner, so nobody knew who to ask.
B. Nobody independent checked the work, so the error reached a product team.
C. The board had too many columns, so the card got lost between stages.
D. The product team asked for the change too late in the week.

**Answer:** B. A reviewer should be a different person from the contributor. When the same person builds and checks the work, a mistake can slip through, which is why review needs its own role.

## Key Takeaways

- **Manage it like a product:** Name the users, the team, and the scope. Keep one ordered backlog that includes design time.
- **Rank with shared rules:** Score every request on demand, impact, effort, and risk. Then choose now, later, or not now, and explain the reason.
- **Make roles and work visible:** Give each item one owner, contributors, and a reviewer. Keep a simple board with clear stages so anyone can see where work stands.

With these habits, a small team can say what it will do, who will do it, and when it will be reviewed. Other lessons cover the detail behind some of these steps, such as how requests are written, how versions are numbered, and how the team talks with users.

## Sources

- [Figr: How to Prioritize Your Product Backlog Without the Chaos](https://figr.design/blog/how-to-prioritize-product-backlog)
- [Figr: How to Manage Product Backlogs and Design Tasks in a Unified System](https://figr.design/blog/how-to-manage-product-backlogs-and-design-tasks-in-a-unified-system)
- [Design Systems Collective: Productizing your design system (Workday Canvas)](https://www.designsystems.com/productizing-your-design-system/)
- [Zeroheight: Managing Design System Work](https://zeroheight.com/help/guides/managing-design-system-work/)
- [Sandy Lam: Design System Backlogging](https://www.linkedin.com/pulse/design-system-backlogging-sandy-lam)
- [Koruux: Design backlogs management tips for Product Manager](https://www.koruux.com/blog/tips-to-manage-design-backlogs/)
- [Knapsack: What do design system product managers do?](https://www.knapsack.cloud/blog/what-do-design-system-product-managers-do)
- [Slack: How to Build a Project Management Workflow That Works](https://slack.com/blog/productivity/how-to-build-a-project-management-workflow-that-works)
- [Success Knocks: Managing design workflows for a 5-person team](https://successknocks.com/managing-design-workflows-for-a-5-person-team/)
- [UXPilot: Design Operations For Product Teams: 7 Practices That Scale](https://uxpilot.ai/blogs/design-ops)
- [Shopify Polaris: Contributing to Polaris React](https://polaris.shopify.com/contributing/components)
- [ParallelHQ: What Is a Product Backlog? The Complete Guide for Startup Teams](https://www.parallelhq.com/blog/what-product-backlog)
