Book a call

WritingOperating model & teamsPart 2 of 4 in The operating model

Design system team structure: roles, org charts and how teams grow

Who actually does the work of a design system, who do they report to, and how many of them do you need? Every role, three org charts from two people to twenty, and how to run a system with no dedicated team at all.

On this pageThe roles a design system needs
  1. The roles a design system needs
  2. How many people, at what size?
  3. Org chart: the founding pair
  4. Org chart: a product team of six to eight
  5. Org chart: a platform organisation of about twenty
  6. Running the system with no dedicated team
  7. What a dedicated team should and shouldn't do
  8. Where should the team report?
  9. Who's responsible for what
  10. Signs it's time to grow the team
  11. The short version
  12. Frequently asked questions
  13. Further reading

The short answer

A design system team needs, at minimum, a designer and an engineer working as a pair, with one of them acting as lead. As the company grows it adds a dedicated lead or product manager, more engineers (including native iOS and Android), and shared specialists for accessibility, content and enablement, plus champions in every product team. Typical sizes: no dedicated people at a startup, 1–3 at a scale-up, 4–8 at a mid-sized company, and rarely more than 20–25 at an enterprise, where growth comes from contributors and automation instead.

  • Aim for at least as much engineering capacity as design capacity. Adoption happens in code.
  • Give the system one accountable leader, whichever department the team reports to.
  • A dedicated team should spend about a third of its time with product teams, not only on its own backlog.

The roles a design system needs

In a small company one person wears several of these hats. In a large one, each is a separate job. What matters is that every responsibility below is somebody's, by name.

RoleWhat they do day to dayKey skillsNeeded from
Design system lead / product managerOwns the roadmap and priorities, talks to leadership and product teams, measures value, removes blockers. Runs the system as a product.Prioritisation, communication, enough design and engineering literacy to make trade-offsScale-up (often a part-time hat)
Design system designerFoundations, component design, Figma libraries, usage guidance, design reviews, workshops.Systems thinking, interaction design, accessibility, Figma, writingStartup (part-time)
Design system engineerBuilds components and the token pipeline; testing, releases, code review of contributions.Front-end architecture, accessibility in code, API design, testingStartup (part-time)
Native engineers (iOS, Android)Build and maintain native component libraries from the shared tokens.Platform expertise and platform accessibilityWhen native apps exist
Accessibility specialistSets standards, reviews components, tests with assistive technology, trains others.WCAG, screen readers, testingScale-up (shared)
Content designerVoice, vocabulary, message patterns, documentation writing standards.UX writing, information architectureMid-sized (part-time)
DesignOps / programme managerRuns rituals, community, enablement, communication and metrics.Operations, facilitationMid-sized
Developer advocate / enablement leadTraining, onboarding, office hours, migration support, sample code.Teaching, engineering credibilityEnterprise
Champions (in product teams)The system's voice in each team: early feedback, local help, contributions. Not a full-time role.Credibility in their team, curiosityScale-up
Every design system role, what it does and when you typically need it. Practitioner view
A mistake we see often

Hiring the designer, forgetting the engineer. A design system team without engineers produces a beautiful Figma library and very little real use. At every size, aim for at least as much engineering capacity as design capacity on the core team.

How many people, at what size?

CompanyDedicated peopleModelContributors
Startup (10–50 people)0Embedded: two owners with ~20% of their timeEveryone, informally
Scale-up (50–300)1–3Small central team, starting hybridA champion per squad
Mid-sized, distributed (300–2,000)4–8Hybrid, written-firstRegional champions plus protected contributor time
Fast-growing, many business units8–14Hybrid with business-unit extensionsExtension teams plus champions
Global enterprise15–25A family of systems with a central platform teamFederated contributors in every portfolio
Team sizes for orientation, not rules. They're broadly consistent with zeroheight's 2025 survey, which found dedicated teams averaging about 3 people at companies under 100 employees, about 4 at 100–499, and about 9 at 500+.

Org chart: the founding pair

For a scale-up, the smallest team that works is two people with a sponsor and a ring of champions. The designer usually doubles as the lead. The engineer often reports into engineering with a dotted line to design.

Head of Designsponsor
System designeralso acts as lead
System engineerreports to engineering, dotted line
Championsquad A, ~10%
Championsquad B
Championsquad C
Championsquad D
The founding pair. Illustration Dashed boxes are champions in product teams, not team members.

Org chart: a product team of six to eight

At a mid-sized company the system becomes a product with its own lead, design and engineering roughly balanced, and specialists shared with the wider organisation.

Director of Design or Platformsponsor
Design system leadproduct owner
2 system designersfoundations, components
3 web engineerscomponents, tokens, tooling
Accessibilityshared, part-time
Content designerpart-time
A team of six to eight. Illustration

Org chart: a platform organisation of about twenty

At enterprise scale the team splits into squads, each with its own focus, held together by a central lead and an enablement squad. Beyond this size, growth comes from contributors and automation, not headcount.

Head of Design Systemsreports to VP Design and VP Engineering

Foundations & tokens

2 designers2 engineers

Web components

1 designer4 engineers

Native

1 designer2 iOS · 2 Android

Enablement & ops

DesignOpsadvocate · content
Federated contributors and champions in every portfolioportfolio extensions, reviews, local support
About twenty people in four squads. Illustration
In practice

At IBM, the Riyadh Air design system was run with six named roles across three companies: IBM, Riyadh Air and Publicis Sapient. See the roles and how they worked together. At CARS24, the internal tools system ran with one system designer, two engineering maintainers and a squad of eight engineers for the build. Read the case study.

Running the system with no dedicated team

Most companies start here, and many stay here for good reason. It's cheap, close to real product needs, and spreads knowledge widely. It also fades quietly unless you set it up deliberately:

  1. Name two owners and protect their time

    One designer and one engineer, each with about 20% of their time (a day a week) reserved in their team's plan and written into their goals. Unprotected time is no time.

  2. Form a small guild

    Interested designers and engineers from each team meet every two weeks for 45 minutes: review new UI, decide what goes into the system, share problems.

  3. Keep a single backlog

    One visible list of system work. Items are picked up by whichever team needs them first, built properly, and contributed back.

  4. Rotate the support role

    A weekly rotation for answering questions in the system channel, so the owners aren't the only point of contact.

  5. Build the system inside product work

    New components are built when a feature needs them, with a little extra time to make them reusable.

What a dedicated team should and shouldn't do

DO
  • Own a public roadmap, planned with product teams each quarter.
  • Ship on a regular rhythm, with release notes written for users.
  • Spend real time with product teams: pairing, pilots, office hours.
  • Run a support rota so questions get fast answers.
  • Review and merge contributions quickly.
  • Measure adoption, satisfaction and value, and report them.
AVOID
  • Building in isolation, then "launching" to teams who weren't involved.
  • Being the only people allowed to change anything.
  • Measuring success by components shipped rather than value delivered.
  • Saying yes to everything, or no to everything.
  • Spending more time on internal process than with product teams.

Where should the team report?

Reporting lines sound like an HR detail, but they shape what the system becomes.

Reports toTends to be good atWatch out for
Design leadershipVisual quality, foundations, design adoptionWeak engineering investment; code lags behind Figma
Engineering / platformCode quality, tooling, releases, technical adoptionDesign quality and the Figma library neglected
ProductPrioritising by business value; roadmap disciplineTreated as a feature team and constantly reprioritised
JointBalance; shared accountabilityNeeds two leaders who genuinely agree, or decisions stall

Our recommendation: one accountable leader for the system, and clear, equal standing for designers and engineers on the team, whichever organisation they formally sit in. A common arrangement is a team reporting into design with engineers holding a dotted line to engineering (or the reverse), plus a joint quarterly review with both leaders.

Who's responsible for what

ActivitySystem leadDesignersEngineersChampionsProduct teams
Roadmap and prioritiesACCCC
Foundations and tokensCA/RRII
Component designIA/RCCC
Component code and APIICA/RCC
Office hours and supportARRR—
ContributionsIR (review)R (review)RA for their own
Adoption in a productCCCRA
A = accountable (makes the call), R = responsible (does the work), C = consulted, I = informed. For decision rights in full, see governance.

Signs it's time to grow the team

  • Requests wait more than a few weeks for a first response.
  • The part-time owners are always too busy with product work.
  • Teams are building local copies of system components.
  • A second platform, brand or business unit is coming.
  • Nobody has time to measure adoption or write release notes.

When it's time, make the move carefully. Hire from inside where you can (the part-time owners often make the best first dedicated members), turn the guild into a champions network, announce clearly what changes and what doesn't, and clear the oldest requests in the first quarter. Trust is earned by response time. For the cost side of that decision, see design system ROI.

The short version

  • Start with a designer and an engineer as a pair; balance design and engineering at every size.
  • Add a lead, native engineers and shared specialists as the company grows; champions in every team.
  • Without a dedicated team: protected time, a guild, one backlog and a support rota.
  • A dedicated team runs like an internal product company and spends a third of its time with product teams.
  • One accountable leader, whatever the reporting line.

Frequently asked questions

How big should a design system team be?

Zero dedicated people at a startup (two part-time owners), 1–3 at a scale-up, 4–8 at a mid-sized company, and 15–25 at the largest enterprises. Beyond that, scale comes from contributors and automation.

Should the team sit in design or engineering?

Either can work. What matters more is one accountable leader and equal standing for designers and engineers. Joint quarterly reviews with both design and engineering leaders keep it balanced.

What does a design system designer do?

Designs foundations and components, maintains the Figma library, writes usage guidance, reviews product designs for system use, and runs workshops and office hours.

Do you need a dedicated design system engineer?

Yes, as soon as you have a dedicated team at all. Without engineering capacity the system never reaches code, and code is where adoption and most of the savings happen.

What are design system champions?

Designers or engineers in product teams who spend a small share of their time (often about 10%) as the system's local voice: early feedback, local help and contributions.

Further reading