Christoph HellmuthDesign Engineering Studio

Field guide · 100 working days

Zero to Design System in 100 Days

The day-by-day playbook I use with scaling product teams: from UI chaos to an adopted system with tokens, components, Figma↔code parity, pilots, connected delivery, patterns, docs, and governance. Built for adoption, not shelfware.

Christoph HellmuthDesign engineer · 16+ years · enterprise design systems christophhellmuth.com

Contents

Four phases, one hundred days

Work through it in order. Skip nothing in Phase 1 or 2. Adoption in Phase 4 is where most internal projects die.

  1. 00 How to use this guide 2
  2. 01 Why 100 days works 3
  3. 02 Before day 1: prerequisites 4
  4. 03 Pilot-first proof 5
  5. 04 The four-phase map 6
  6. 05 Phase 1: Align (days 1-14) 7
  7. 06 Phase 2: Foundations (days 15-49) 8
  8. 07 Token architecture 9
  9. 08 Component priority tiers 10
  10. 09 Patterns & the six-area model 11
  11. 10 Phase 2: week-by-week plan 12
  12. 11 Phase 3: Connect (days 50-77) 13
  13. 12 Connected delivery (npm) 14
  14. 13 Phase 3: week-by-week plan 15
  15. 14 Phase 4: Adopt (days 78-100) 16
  16. 15 Governance starter kit 17
  17. 16 Hot Potato & collaboration rhythm 18
  18. 17 Phase 4: week-by-week plan 19
  19. 18 Success metrics worksheet 20
  20. 19 Ten ways systems fail 21
  21. 20 AI guardrails 22
  22. 21 Master 100-day checklist 23
  23. 22 What to do next 24
Zero to Design System in 100 DaysPage

00 · How to use this guide

A playbook, not a wish list.

This is the sequencing I run in paid engagements, compressed into a plan your team can execute internally or with a senior partner.

Who it's for: product companies with ~20-200 people, a real web product (often app + marketing site), a small design team, and engineers rebuilding the same UI patterns. You have leadership buy-in, or you're the leader making the case.

Who it's not for: pre-revenue startups with no product yet, teams that want "cheap screens" instead of a system, or orgs where engineering won't touch a shared component library.

How to read it: Phase 1 is non-negotiable. Phase 2 is where most of the build happens. Phase 3 makes the system real in production. Phase 4 is adoption: without it, you built shelfware.

Pair with the audit checklist

Run the 40-Point Design System Audit on day 1. Your reds become the backlog. This guide tells you the order to fix them.

What's new in this edition: pilot scorecard and Measuring Spoon extraction (proof before scale), connected npm delivery (not copy-paste), patterns and six-area coverage, Hot Potato collaboration, canon vs expanded governance, docs as a store, and AI guardrails. Deeper context lives in the full compendium.

Time commitment: plan for 0.5-1 FTE dedicated to the system (design engineer, or design + eng pair), plus ~2-4 hours/week from a sponsor in leadership. Squads keep shipping features; the system earns its place by removing rework.

100 working days ≈ 20 calendar weeks at 5 days/week. Adjust pace if you're part-time on the system. Sequence stays the same.

00 · How to use this guidePage

01 · Why 100 days works

Long enough to adopt. Short enough to finish.

Most "design system projects" stall because they start in the wrong place, ship components nobody uses, or never assign an owner. One hundred days forces the right sequence.

I've led systems at enterprise scale (dozens of teams, millions of users on Aurora) and in fast-moving scale-ups. The pattern is consistent: tokens first, core components second, parity third, adoption last. Skip a step and you pay the inconsistency tax again within two quarters.

One hundred days is not arbitrary. It maps to what a focused team can actually deliver:

The adoption principle

A mediocre system that's adopted beats a beautiful one that's ignored. I build for adoption from day one: pilot squads, visible milestones, governance before the library is "complete."

Skip the "build the whole system, then convince people" trap. Hitch to funded product work in Phase 1, extract components as you ship (Measuring Spoon Cycle), and prove value before you ask for a permanent team.

On one product, a single consistency fix cut reclamations ~90%. No full redesign. Same component, same behavior, everywhere. That's what a system is for: operations and revenue, not a Figma trophy case.

If you need less: stop after Phase 2 with a usable foundation. If you need more: extend Phase 3 into a full rollout. The phases still hold.

01 · Why 100 days worksPage

02 · Before day 1

Get these in place or wait.

The system won't survive politics. Sort sponsorship and access before you tokenize a single color.

1. Executive sponsor. One leader (Head of Design, VP Eng, or CPO) who will defend system time against feature pressure. They don't need to run it. They need to unblock it.

2. System owner (named). Even 20% of one person's role. "Everyone owns it" means no one owns it. The owner runs office hours, triages contributions, and keeps the roadmap visible.

3. Design + engineering pair. At least one designer and one engineer with authority to change the shared library and merge to main. A system in Figma alone is a draft.

4. Access. Figma org/libraries (edit), repo + Storybook (write), staging environment, analytics if you track UI errors.

5. Scope boundary. Pick 1-2 surfaces for the first pilot (e.g. settings area + onboarding). Not the whole product. Hitch to work that already has budget: rebrand, replatform, or a funded feature migration beats a sandbox library.

6. Pilot host scored. Run the Pilot Scorecard (page 5) on 3-5 candidate flows before you commit. Highest score wins. Politics becomes sequence.

7. Working agreement. Weekly 30-min sync. Review turnaround: 48h for async feedback. Slack/Teams channel named and archived. Decision log location chosen.

Day 0 checklist

Sponsor confirmed · Owner named · Design + eng contacts assigned · Figma + repo access granted · Pilot surface chosen and scorecard completed · Kickoff scheduled · Audit checklist printed

Your day 0 notes (sponsor, owner, pilot surface)
02 · Before day 1Page

03 · Pilot-first proof

Prove on product work. Then scale.

The system is the notes in the margin, not the textbook. Extract from real shipping UI; don't invent components in a vacuum.

The Measuring Spoon Cycle: make product UI on a pilot → extract what repeats → reuse on the next product → repeat. Your 100-day plan is one long Measuring Spoon loop, not a big-bang library launch.

Hitch to moving work. Replatforms, rebrands, and merger integrations already have executive attention. Embed there. Don't build a parallel "design system project" that competes for the same engineers.

Five pilot types (pick what fits your politics):

Pilot Scorecard (score each candidate 0-10; sum and sort):

FactorWhat you're scoring0-10
Components neededHow much of the system will this exercise force you to build?
Patterns neededFlows, not just atoms (forms, tables, settings)
Business valueRevenue, retention, or exec visibility
FeasibilityTech stack, access, timeline realism
ReceptivenessWill the host squad actually use what you extract?
Scope clarityBounded surface vs endless "platform"
IndependenceCan you ship without blocking on other teams?
PublicityWill leadership see the win?

Multichannel orgs

Run up to three pilots concurrently (app, marketing, logged-out). One pilot's components rarely fit the second channel. Sequential hero projects teach slower.

Full pilot playbook: Pilot-First guide

03 · Pilot-first proofPage

04 · The four-phase map

Align → Foundations → Connect → Adopt

Each phase has a single outcome. Don't start the next until the current one is demonstrably done.

1-14

Phase 1 · Align

Audit complete. Stakeholders aligned. Charter signed. Backlog prioritized. Cost of inconsistency estimated.

15-49

Phase 2 · Foundations

Primitive + semantic tokens in Figma and code. 15-20 core components with full states. Storybook started.

50-77

Phase 3 · Connect

Figma↔code parity on core set. Docs site or Storybook docs complete. Pilot surface migrated. Token pipeline automated.

78-100

Phase 4 · Adopt

2+ squads shipping on system only. Governance rituals running. Deprecation plan for legacy patterns. Owner trained.

Exit criteria (day 100)

You can answer yes to all five: (1) one governed version of each core component in production, (2) tokens are the source of truth in Figma and code, (3) a new engineer built a screen from docs alone, (4) governance owner and RFC process exist, (5) leadership can see adoption metrics.

Detailed week plans start on page 6. Token and component references on pages 8-9.

04 · The four-phase mapPage
Phase 1

Align · days 1-14

Outcome: shared picture of reality + prioritized plan

You cannot fix what you haven't measured. Phase 1 is audit, inventory, and alignment. No component building yet.

DayFocusDeliverable
1-2Kickoff + accessCharter doc: goal, scope, roles, rituals. Baseline screenshots of pilot surface.
3-5Run 40-point auditScore all lenses. Count button/input/card variants in Figma + code.
6-7Code + Figma inventorySpreadsheet: component name, locations, drift notes, owner squad.
8-9Stakeholder interviews3-5 short calls: designers, eng leads, PM. Pain in their words.
10ROI framingEstimate rework hours/month, onboarding drag, user-facing inconsistency cost.
11-12Pilot Scorecard + roadmapScore 3-5 candidate hosts. Sort high to low. Assign Phase 2-4 work to top pilot.
13Readout prepExecutive summary (1 page). Top 3 priorities highlighted.
14Live readoutDesign + eng in the room. Decisions logged. Phase 2 kickoff date set.

Phase 1 done when

Leadership has seen the audit. Pilot surface is agreed. Token + core component work is scheduled with named owners. No open debate about whether you need a system.

05 · Phase 1: AlignPage
Phase 2

Foundations · days 15-49

Outcome: tokens + core components in Figma and code

Five weeks of build. Work in vertical slices: one component fully done (Figma + code + Storybook) before starting the next. No "Figma complete, code later."

Week 3 (days 15-19): Token architecture. Primitive palette, semantic aliases, spacing/radius/type scales. Figma variables published. Export pipeline to CSS/Tailwind stub.

Week 4 (days 20-24): Tier 1 components: Button, Link, Icon, Text styles. All states in Figma + React. Storybook stories live.

Week 5 (days 25-31): Form controls: Input, Textarea, Select, Checkbox, Radio, Switch, Label, Field error. Keyboard + focus on every control.

Week 6 (days 32-38): Feedback + layout: Alert, Badge, Card, Divider, Stack/Grid primitives, Skeleton.

Week 7 (days 39-45): Overlays: Modal, Tooltip, Popover, Tabs. Focus trap on Modal. Reduced-motion respected.

Week 8 (days 46-49): Midpoint review with squads. Fix parity gaps. Deprecate obvious duplicates in pilot surface.

Definition of done (each component)

Figma component on tokens · all states · code matches Figma · TypeScript props · Storybook docs · WCAG AA contrast · keyboard accessible · usage note (when to use / when not)

06 · Phase 2: FoundationsPage

07 · Token architecture

Two layers. One source of truth.

Primitives hold raw values. Semantics hold intent. Components never reference primitives directly.

Primitive (raw)

color-blue-500: #3b5bdb color-gray-900: #111827 space-4: 1rem radius-md: 0.625rem

Semantic (intent)

color-action: color-blue-500 color-surface: color-gray-900 space-inline-md: space-4 radius-control: radius-md

Naming convention: {category}-{role}-{variant?}. Examples: color-text-primary, color-border-subtle, font-size-body, elevation-overlay.

Export path: Figma variables → JSON (Tokens Studio or native) → Style Dictionary → CSS custom properties / Tailwind theme extension. One pipeline, two consumers.

Theming: light/dark switches re-point semantics only. color-surface maps to different primitives per theme. Components unchanged.

Accessibility baked in

Define color-text-on-action and color-action as a verified pair (4.5:1 minimum). Test both themes before you ship Button.

07 · Token architecturePage

08 · Component priority tiers

Build in this order. Always.

Tier 1 unlocks 80% of screens. Tier 2 covers forms and feedback. Tier 3 is product-specific. Don't build Tier 3 until Tier 1 is adopted.

States checklist (every interactive component): default · hover · focus-visible · active · disabled · loading (if async) · error (if input) · empty (if container)

Figma structure: one library file per tier during build; merge to single published library at day 45. Component properties mirror code props (variant, size, disabled).

Parity rule

If it's in Figma, it's in Storybook. If it's in Storybook, it matches Figma within 2px spacing tolerance. Code Connect or equivalent links them for designers browsing the repo.

Three Times Is a Pattern: don't add to the system until a third squad needs the same thing. Snowflakes stay in the expanded universe until the pattern proves out.

08 · Component priority tiersPage

09 · Patterns & the six-area model

Components are the easy part. Patterns are where teams bleed time.

Mature systems cover six interlocking areas. Squads ask for buttons; the expensive bugs live in regions, content, and flows.

Layout
Grid, spacing, breakpointsThe rhythm everything sits on. Token-driven, not per-screen magic numbers.
Styles
Color, type, icons, motionSemantic tokens only. Components never hold raw hex.
Components
Buttons, inputs, cardsYour Tier 1-2 build. One canonical version per variant.
Regions
Nav, page templates, form layoutsWhere components compose into screens. Document 2-3 region templates in Phase 3.
Content
Voice, tone, terminology, error copyUX writing is part of the system. Error states ship with approved microcopy.
Usability
WCAG, keyboard, i18nBaked into components, not bolted on after. Plan DE/EN token expansion if you serve EU.

Patterns to prioritize in Phase 3 (after Tier 1 adoption): settings panel, data table with sort/filter, empty states, onboarding wizard. These are "products" in your docs, not loose buttons.

Docs: store, not warehouse

Lead your reference site with recipes and flows (checkout, settings, onboarding). Nest components inside what teams actually build. Nobody walks into a store to buy loose bricks.

09 · Patterns & six areasPage

10 · Phase 2 week-by-week

Days 15-49 at a glance

DaysBuild focusReview checkpoint
15-19Token spec + Figma variables + CSS exportDesign + eng sign-off on naming doc
20-24Button, Link, Icon, typography utilitiesDemo: 3 button variants in Storybook + Figma
25-31Full form control setAccessibility pass: keyboard-only form completion
32-38Alert, Badge, Card, layout primitivesDesigner builds a settings card in Figma from library only
39-45Modal, Tooltip, TabsFocus trap test on Modal. Screen reader spot check.
46-49Buffer + parity fixes + publish library v0.1Midpoint readout: squad leads see live Storybook

Async rhythm: Mon/Tue build · Wed WIP Loom to channel · Thu review comments · Fri merge + changelog entry.

Your Tier 1 ship date (target day)
Blockers / dependencies
10 · Phase 2 week-by-weekPage
Phase 3

Connect · days 50-77

Outcome: production parity + docs + pilot migration

Phase 3 turns a library into a system: automated token sync, complete documentation, and a real product surface running on governed components only.

Token pipeline (days 50-56): CI job exports Figma variables on merge. Style Dictionary builds CSS + Tailwind + JSON. PR fails if token drift detected.

Documentation (days 57-63): Storybook docs per component plus 2-3 pattern recipes (settings, table, onboarding). Products first, components nested inside. Optional: docs site if you need search and onboarding paths.

Tier 3 components (days 64-70): Data table and navigation for your product. Build only what the pilot surface needs.

Pilot migration (days 71-77): One squad rebuilds the pilot surface (e.g. settings) using system components only. Track: lines of custom CSS removed, components imported, time to ship vs. baseline.

Phase 3 done when

Pilot surface is in production on system components. Docs answer "how do I build X?" without Slack. Token export is automated, not manual copy-paste.

11 · Phase 3: ConnectPage

12 · Connected delivery

Infrastructure installs. Libraries get copied.

Bootstrap is a download. Your design system should be a versioned package product teams import. Copy-paste drifts on day one.

Connected means:

Week 50-52 checklist:

Code is the territory

Figma is the map. Users touch production. When designers join PRs for component edge cases, handoff stops being a cliff. Connected delivery makes that possible.

Speaks both Figma and the repo: tokens in variables, components in a package, docs that show live imports.

12 · Connected deliveryPage

13 · Phase 3 week-by-week

Days 50-77 at a glance

DaysFocusDeliverable
50-52Package + token CInpm package v0.1 + automated token export
53-56Code Connect / Figma linksCore components linked in Figma
57-60Storybook + pattern recipesTier 1-2 documented + 1 flow recipe page
61-63Onboarding doc"Build your first screen" guide for new hires
64-67Table + nav (if needed)Tier 3 components for pilot surface
68-70Deprecation markersLegacy components tagged in code + Figma
71-74Pilot squad sprintFeature branch using system only
75-77Merge + measureProduction deploy + before/after metrics

On one project, Lighthouse went 34 → 77 partly from system discipline: fewer one-off components, less CSS chaos. Performance is a design-system outcome whether your roadmap admits it or not.

13 · Phase 3 week-by-weekPage
Phase 4

Adopt · days 78-100

Outcome: multi-squad adoption + governance that survives you

Building is the easy part. Phase 4 is rollout, rituals, and making sure the system doesn't rot when the initiative ends.

Squad rollout (days 78-88): Squads 2 and 3 migrate one feature each. Name one design + one eng champion per squad. Office hours twice weekly for 30 min. Capture questions → doc updates same week.

Governance live (days 89-94): RFC template for new patterns. PR review checklist for design QA. Changelog published every release. Owner runs triage.

Enablement (days 95-97): 60-min handover session: how to contribute, how to request components, how to deprecate. Record it.

Close (days 98-100): Metrics review with sponsor. 90-day backlog for Tier 3 gaps. Decision: fractional partner, hire, or internal owner only.

Phase 4 done when

At least two squads shipped production features on the system. Governance RFC merged at least once. Owner can run the next quarter without you.

14 · Phase 4: AdoptPage

15 · Governance starter kit

Boring on purpose. Decisive by design.

Most systems die from no owner and no process. This is the minimum viable governance. Copy it.

Roles

Canon vs expanded universe

Flow week / Systems week (alternate if embedded in product teams):

Without explicit alternation, system work loses every sprint planning fight. Calendar it with the eng manager.

RFC template (one page)

Rituals

PR checklist (design QA)

15 · Governance starter kitPage

16 · Hot Potato & collaboration rhythm

Pass work in hours, not weeks.

Design intent survives handoff when handoff barely exists. Hot Potato beats comp-to-Jira-to-sprint every time.

Hot Potato process: designer and engineer in the same session (virtual counts). Engineer drives implementation early. Design explores inside real constraints. Pass work back and forth the same day.

Run it in Phase 2: pick one Tier 1 component. One designer, one engineer, shipped by end of day. Record the session as the pattern for squads.

Five collaboration rituals to institutionalize by Phase 4:

The seam-owner

Front-end engineering is the hinge. A design engineer (or senior FE with systems taste) translates design language into durable code. Without someone in the seam, you get beautiful Figma and chaotic production.

Deeper teamwork guide: Design × Development Collaboration

16 · Hot Potato & collaborationPage

17 · Phase 4 week-by-week

Days 78-100 at a glance

DaysFocusDeliverable
78-80Rollout kickoffSquad migration briefs + deadlines
81-85Squad 2 migrationOne feature live on system components
86-88Squad 3 migrationSecond feature live
89-91Governance docs publishedRFC + PR checklist in repo
92-94First external RFC mergedChangelog entry + comms to org
95-97Enablement sessionRecording + onboarding path updated
98-99Metrics reviewBefore/after deck for sponsor
100Handover90-day backlog + owner sign-off
Your day 100 owner + next-quarter top 3
17 · Phase 4 week-by-weekPage

18 · Success metrics worksheet

People succeed, not systems.

Measure whether squads ship faster and happier. Component counts and doc page views are vanity metrics unless teams feel relief.

MetricDay 1Day 50Day 100Target
Button variants in production1
Core components at Figma↔code parity15-20
% pilot surface on system components100%
Squads shipped on system (count)2-3
Hours/week rework on UI patterns↓ 50%+
New hire: time to first screen (hours)↓ 40%+
Slack questions "which component?" / week→ 0
Hardcoded hex values in pilot surface0
Package imports in product repos (count)2+ apps
Squad leads report "relief" (Y/N interviews)Yes
WCAG AA failures on core components0

Align one system metric to an active product OKR each quarter. Example: "Standardize billing forms → fewer support tickets → WCAG 2.2 AA on all form components."

Qualitative signals

Design and eng agree on what "done" means. PMs reference the system in specs. Legacy components have owners and deprecation dates. Nobody says "just this once" without an RFC. New hires build a screen from docs in week one.

18 · Success metrics worksheetPage

19 · Ten ways systems fail

Seen them all. Plan around them.

If you recognize your team below, fix the process before you add another component.

1. Make System, Use SystemBuild the whole library, then pitch for adoption. Fix: pilot on funded work first (page 5).
2. No sponsorFeature pressure eats system time by week 4. Fix: charter signed by exec before day 1.
3. Figma-only deliveryBeautiful library, zero production impact. Fix: vertical slices; code is part of definition of done.
4. Copy-paste "adoption"Teams download a ZIP and drift immediately. Fix: connected npm package by day 52.
5. Big-bang rewrite"We'll migrate everything in Q4." Q4 never comes. Fix: pilot surface wedge; prove in 6 weeks.
6. No owner after day 100System drifts within one quarter. Fix: name owner on day 0; governance before build finishes.
7. Kitchen-sink Tier 3Building charts before Button is adopted. Fix: tier discipline; 3× rule before systemizing.
8. Docs as parts catalogButton docs nobody reads. Fix: pattern recipes and store IA (page 9).
9. Comparison trapMeasured against Material team size. Fix: needs of your org only; 80/20 coverage wins.
10. Perfectionism18 months in, 4 components, no adoption. Fix: ship Tier 1 in 10 days; iterate in public.

The honest line

It doesn't have to be this way. Most failures are governance and sequencing, not talent.

19 · Ten ways systems failPage

20 · AI guardrails

AI scales output. Your system scales correctness.

One prompt can generate a dozen plausible screens that all disagree. Without guardrails, AI adds entropy. Machine-readable tokens are the moat.

Make your system AI-readable by day 77:

AI accelerates production. It doesn't replace intent. Designers who strengthen systems thinking, ethical constraints, and cross-functional collaboration become more valuable, not less.

I placed 1st at the Into Design Systems AI Hackathon 2026 with a Figma plugin that smart-swaps mismatched components. The system was the constraint that made AI reliable.

Phase 4 action

Add an "AI usage" section to your docs: which components are safe for codegen, which patterns need human review, how to prompt with semantic tokens.

20 · AI guardrailsPage

21 · Master 100-day checklist

Tick at phase end. Gaps = your backlog.

✓CheckpointPhase
Pilot Scorecard completed; host squad committed1
Audit complete, readout done, ROI estimated1
Sponsor + owner named in writing1
Pilot surface chosen and baselined1
Primitive + semantic tokens in Figma and code2
Tier 1 components shipped with full states2
Tier 2 form controls + overlays complete2
Storybook live with core stories2
npm (or internal) package published; 1+ app imports it3
Token export automated in CI3
Docs: components + 1 pattern recipe (store IA)3
Pilot surface migrated and in production3
2+ squads shipped features on system4
Champions named in 2+ squads4
Hot Potato session run; rhythm documented4
Canon vs expanded tiers published4
RFC + PR checklist published4
AI guardrails section in docs4
Enablement recorded; owner trained4
Day 100 metrics reviewed with sponsor4
Top 3 gaps remaining after day 100
21 · Master checklistPage

22 · What to do next

Run it yourself, or bring a senior pair of hands.

This guide is enough for a capable internal team with protected time. If you're moving faster, or you've stalled before, I help scaling product teams scale, govern, and ship.

Design System Audit

€2,500-4,500

Your Phase 1 in 1-2 weeks: findings, ROI, prioritized roadmap. Fee credited toward a build.

Foundations Sprint

€12,000-25,000

Phase 2 delivered: tokens, core components, docs starter, Figma↔code connection. Milestone-based.

Fractional Design Systems Partner

from €5,000/mo

Phase 4 and beyond: governance, new components, design QA on PRs.

Also see: Full 120-page daily edition · Full compendium (all guides) · Pilot-First playbook · 40-Point Audit · How we work

Want a senior second opinion on your 100-day plan?

Book a free 30-minute consult. I'll stress-test your sequence and name the highest-ROI starting point. No pitch.

Get a free consultation · christophhellmuth.com · post@christophhellmuth.com

© Christoph Hellmuth · Free to share with attribution · Not for resale · Full compendium → · Collaboration ebook →

Christoph Hellmuth · Design Engineering StudioPage