Book a call

WritingBuilding a systemPart 2 of 3 in Planning the system

A design system roadmap for the first twelve months

Most first-year plans are a list of components with dates, and they fail the same way. A plan across foundations, components, operations and adoption, with a gate at the end of every quarter that earns the next.

On this pageWhy most first-year plans fail
  1. Why most first-year plans fail
  2. The first twelve months
  3. Gates: how each quarter earns the next
  4. Build inside real projects
  5. Rhythms to set up in month one
  6. Adjusting the plan to your size
  7. The short version
  8. Frequently asked questions
  9. Further reading

The short answer

A realistic first-year design system roadmap runs four workstreams side by side (foundations, components, operations and adoption) across four quarters: start (audit, tokens, the eight everyday components, an owner), prove (containers and feedback components, a request process, champions), spread (data and navigation components, dark mode, the first outside contribution) and settle (the hard components, deprecations, next year's plan). Each quarter ends with a gate: something you can point to that earns the next quarter's funding. And every component is built inside a real product project, never in isolation.

  • Every quarter should deliver something teams can use immediately, so trust builds as you go.
  • Put the operating rhythms (support, office hours, releases, health checks) in the calendar in the first month.
  • Plan components by complexity, not by count: the hard ones belong in quarter four.

Why most first-year plans fail

The typical first-year plan is a list of components with dates. It fails in a predictable way: the team builds in isolation for two quarters, launches a library nobody asked for, and spends the second half of the year persuading teams to adopt it. Meanwhile leadership asks what they got for the money.

The plan below fixes that with three ideas: workstreams beyond components, a pilot product for every quarter, and a gate at the end of each quarter. It's written for a mid-sized product company starting from shared styles or basic tokens. Adjust the scope to your size; keep the shape. Illustration

The first twelve months

M1M2M3M4M5M6M7M8M9M10M11M12
Audit and tokens
Core components
Operations
Pilots and adoption
Gates
Focused workOngoing
Four workstreams across a year, with a gate at the end of each quarter. Components run all year, but inside pilot projects, not on their own.
Q1 · StartQ2 · ProveQ3 · SpreadQ4 · Settle
FoundationsAudit. Colour, type, spacing and layout as tokens. Token pipeline.Semantic tokens complete. Contrast checks automated.Dark mode as a second theme.Density modes. Token audit.
Components8 basics: button, field, select, checkbox, radio, switch, link, alert.Containers and feedback: dialog, card, tabs, toast, menu, empty state.Data and navigation: table, pagination, badge, tag, side menu.The hard ones: date picker, search, advanced table features.
OperationsOwner named. Who decides what. Versioning rules.Request and contribution process. Docs template.First outside contribution. Monthly health check.First deprecations. Next year's roadmap.
AdoptionPilot team: a new settings page.Second pilot. Champions in each team.Second and third teams adopt. Office hours.Migration dashboard. Most new work on the system.
GateThe pilot ships using only tokens.The pilot team is measurably faster or has fewer UI bugs.A team adopts without hand-holding.Adoption trend and savings reported to leadership.
The plan, quarter by quarter. Illustration The component order follows which components to build first; the hard ones wait until the team has practice.

Gates: how each quarter earns the next

A gate is a concrete result, agreed with your sponsor at the start of the quarter, that shows the system is working. It turns "trust us" into "here's what happened", and it's what keeps funding coming in stages rather than as one big bet.

GOOD GATES

Observable and owned by product

"The settings page shipped using only system tokens." "The onboarding team reported 30% fewer UI bugs than last quarter." "Team C adopted the table without asking us for help."

WEAK GATES

Output, not outcome

"We built 15 components." "The docs site is live." Both can be true while nobody uses the system. Count use and change, not output.

Measure against a baseline taken in the first month; see design system metrics. For the money side, the ROI calculator shows why year one rarely pays for itself, and why staged funding makes sense.

Build inside real projects

The single biggest predictor of a system people use, in our experience, is that its components are built inside real product work: a pilot team needs a settings page, so the system builds the form components with them, for that page. Dan Mall makes the same argument in Design That Scales. Components built in isolation solve imagined problems; components built in pilots solve real ones and arrive with their first users.

  1. Choose a pilot with a deadline

    A real feature, shipping this quarter, with a team that's willing.

  2. Build what the pilot needs, as system components

    Designed for reuse, but proven on one real screen first.

  3. Release as beta, then stable

    The pilot uses beta components; once they've survived production, they become stable for everyone.

  4. Share the story

    "The billing team shipped two weeks early using the system" persuades where statistics don't.

Rhythms to set up in month one

How oftenWhatWhy
DailyAnswer the support channelFast answers keep people using the system instead of working around it
WeeklyOffice hours; triage new requestsHelp teams build with the system; decide quickly what's shared
Every two weeksRelease, with notesA predictable rhythm lets teams plan updates
MonthlyHealth check; Figma–code twin check; usage and detach dataSpot drift and problems early
QuarterlyGate review; token and debt audit; roadmap updateKeep the plan honest
YearlySurvey; re-score complexity; budget and staffing reviewDecide the next stage
Rhythms are much harder to add later. Put them in the calendar before the first component ships. Practitioner view

Adjusting the plan to your size

  • Startup: do quarter one only, slowly: tokens, a themed library, one owner. See design systems for startups.
  • Scale-up: the plan as written, with a designer and one or two engineers.
  • Enterprise: the same shape per portfolio, plus a council and a migration plan for legacy products. See migrating legacy products.
In practice

At CARS24, the internal tools system reached 93 component sets in a three-to-four-month runway to a beta for leadership, with tokens and Storybook set up alongside engineers new to design systems. Read the case study.

The short version

  • Four workstreams: foundations, components, operations and adoption.
  • Four quarters: start, prove, spread, settle.
  • A gate at the end of each quarter earns the next quarter's funding.
  • Build every component inside a real pilot project.
  • Set up the rhythms in month one.

Frequently asked questions

What should a design system roadmap include?

Foundations, components, operations and adoption, planned together by quarter, with a measurable gate at the end of each quarter and the pilot projects that will use each set of components.

How long does it take to build a design system?

A useful core (tokens and the everyday components, in real use) takes a mid-sized team about two quarters. A system most new work uses takes about a year. It's never finished; it's run like a product.

What should we build first?

Tokens, then the components used most often and causing the most inconsistency, usually buttons, fields, selects and alerts. Save complex ones like the date picker for later.

How do we keep leadership's support?

Agree a gate with your sponsor each quarter, measure against a baseline, and report outcomes (faster delivery, fewer UI bugs, teams adopting) rather than component counts.

Further reading