Marcus Andrey Study
Ler em português Library

Design Systems · For leads · 5 min read

Funding and staffing a design system team

For leads: how to get a design system the people and time it needs. Why it has to be funded like a product, which roles it needs at each stage, the ways teams pay for it, and how to write the ask without inventing numbers.

Most design systems don't fail because of bad components. They fail because nobody's job is to keep them alive. A system built in spare time looks great for six months, then falls behind the products, then gets forked. A lead's job is to turn "a few of us care about this" into named people, protected time and a line in a budget, in that order.

What you'll be able to do after reading:

  • Explain why a system needs to be funded like a product, not a project
  • Name the roles a system needs at each stage
  • Choose a way to fund it that fits your organisation
  • Write a one-page ask with numbers you can defend

1. A product, not a project

Brad Frost quotes Nathan Curtis on the difference: a style guide is an artefact, while "a design system is a living, funded product with a roadmap & backlog, serving an ecosystem" (Atomic Design, chapter 5). A project ends and its team moves on. A product has users, releases and someone who answers for it next year.

That changes what you ask for. Not "three months to build a library", but "a team that keeps the products consistent and fast to build, for as long as we have products".

Frost's order is the one that works in most organisations: make a thing, show that it's useful, then make it official with real time, budget and people. Asking for a team before you've shown anything is asking for faith.


2. Who you need, stage by stage

Worked example, not a benchmark
StageWhat Harbour isWho works on itModelFunded as
Prove it
first 6 months
Inventory, primitives, 8 components for the booking appOne designer and one engineer from the booking team, half their timeSolitaryTime borrowed from a product team, agreed with its lead
Make it official
year 1
Tokens with modes, 25 components, docs site, the console adoptingTwo designers, two engineers, full time; a product manager one day a weekCentralisedIts own team, with a budget line and a roadmap
Scale it
year 2 and on
Two brands, contribution process, deprecations, adoption trackingThe same core plus a content designer and accessibility time; one contributor named in each product teamCentralised core, federated contributorsCore team plus contribution time written into product teams' plans
How the people behind Harbour could grow with it. The headcounts are this course's example, chosen to show the shape, not a recommendation: size your team to the products it serves and the work on its roadmap.Example: Marcus Andrey, CC BY 4.0. Stages after Brad Frost's "make a thing, show that it's useful, make it official" (Atomic Design, chapter 5); model names after Nathan Curtis (2015).

The figure is an example, not a benchmark. No public source gives a reliable "right size" for a system team, and the honest answer depends on how many products and platforms it serves. What doesn't change is the mix:

  • Designers who build the Figma library and write the guidance.
  • Front-end engineers who build and release the code. A system with only designers produces a library nobody ships.
  • Someone who runs it as a product: the roadmap, the backlog, talking to product teams. At first that's often the lead, part time.
  • Content and accessibility, part time at first, as a core part rather than a review at the end (see Content and voice in the system and Accessible components).

Frost describes the two sides as makers, who build and govern the system, and users, who apply it in products, and argues the team should be cross-disciplinary, with designers and front-end developers doing the hands-on work.

The team model from Contribution models decides how these people sit: in one product (solitary), in their own team (centralised), or spread across product teams (federated).


3. Ways to pay for it

Funding How it works Watch out for
Borrowed time A product team gives part of two or three people's week It's the first thing cut when a deadline comes
Own team A budget line, a team, a roadmap Can drift from product needs if nobody holds it to adoption
Contribution time Each product team plans some time for system work Only works if it's written into their plans and their goals
Mixed A small core team plus planned contribution time Needs clear decision rights, or it becomes a committee

Most systems go through them in order: borrowed time while you prove it, an own team when it's official, then mixed as more products adopt.


4. Staffing is the hard part

Sparkbox's 2022 Design Systems Survey asked maintainers for their top priorities and top challenges. Staffing was a top priority for 13% and a top challenge for 35%, the largest gap of any area; maintainers who called their system successful were more likely to rank staffing as a priority (Sparkbox, Design Systems Survey 2022). It's 219 self-selected responses, so don't quote it as an industry figure. Use it as what it is: other teams saying this is where they struggled.

What helps in practice:

  • Name people, even when it's part time: "Ana, two days a week" survives a planning meeting better than "the design team".
  • Protect the engineers. Design time is easier to find than front-end time, and a system without code doesn't change products.
  • Plan for the boring work: releases, migrations, answering questions. It's most of the job once the system exists.

5. Write the ask

One page, for the person who owns the budget:

  1. The problem, counted. Your inventory: nine buttons, fourteen blues, three date pickers (see Run an interface inventory).
  2. What it costs now. Real examples: accessibility bugs fixed three times in three products, a redesign that took a quarter because nothing was shared.
  3. What you've shown. What the borrowed-time version already did: the components in use, the screens built with them.
  4. The ask. Named roles, for how long, and the model.
  5. How you'll show it worked. The measures from Showing the value of a design system, and when you'll report them.

Use only numbers you can show the source of: your counts, your timesheets, your bug tracker. If you use an outside study, say what it measured and what it didn't.


6. Common mistakes

  • Asking for a big team before showing a working first version.
  • A system team of designers only.
  • Funding a launch, then nothing for maintenance.
  • "Everyone contributes" with no time planned for it in anyone's goals.
  • Quoting industry ROI figures nobody can trace back to a study.

7. Try it (no tools needed)

  1. Write down who works on your system today, and how many hours a week, honestly.
  2. Mark which stage of the figure you're in.
  3. Write the one role you'd add first, and what it would change in the next six months.

Reflection questions: What would happen to your system if the person who cares most about it left? Who outside design would sign the ask, and what do they need to see?


Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

A roadmap for the system · Showing the value of a design system · Contribution models · When you don't need one yet · Who does what on a product team · Design system governance models · Design system ROI estimate

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close