Field guide · 100 working 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.
Contents
Work through it in order. Skip nothing in Phase 1 or 2. Adoption in Phase 4 is where most internal projects die.
00 · How to use this guide
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.
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.
01 · Why 100 days works
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:
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.
02 · Before day 1
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.
Sponsor confirmed · Owner named · Design + eng contacts assigned · Figma + repo access granted · Pilot surface chosen and scorecard completed · Kickoff scheduled · Audit checklist printed
03 · Pilot-first proof
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):
| Factor | What you're scoring | 0-10 |
|---|---|---|
| Components needed | How much of the system will this exercise force you to build? | |
| Patterns needed | Flows, not just atoms (forms, tables, settings) | |
| Business value | Revenue, retention, or exec visibility | |
| Feasibility | Tech stack, access, timeline realism | |
| Receptiveness | Will the host squad actually use what you extract? | |
| Scope clarity | Bounded surface vs endless "platform" | |
| Independence | Can you ship without blocking on other teams? | |
| Publicity | Will leadership see the win? |
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
04 · The four-phase map
Each phase has a single outcome. Don't start the next until the current one is demonstrably done.
Audit complete. Stakeholders aligned. Charter signed. Backlog prioritized. Cost of inconsistency estimated.
Primitive + semantic tokens in Figma and code. 15-20 core components with full states. Storybook started.
Figma↔code parity on core set. Docs site or Storybook docs complete. Pilot surface migrated. Token pipeline automated.
2+ squads shipping on system only. Governance rituals running. Deprecation plan for legacy patterns. Owner trained.
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.
You cannot fix what you haven't measured. Phase 1 is audit, inventory, and alignment. No component building yet.
| Day | Focus | Deliverable |
|---|---|---|
| 1-2 | Kickoff + access | Charter doc: goal, scope, roles, rituals. Baseline screenshots of pilot surface. |
| 3-5 | Run 40-point audit | Score all lenses. Count button/input/card variants in Figma + code. |
| 6-7 | Code + Figma inventory | Spreadsheet: component name, locations, drift notes, owner squad. |
| 8-9 | Stakeholder interviews | 3-5 short calls: designers, eng leads, PM. Pain in their words. |
| 10 | ROI framing | Estimate rework hours/month, onboarding drag, user-facing inconsistency cost. |
| 11-12 | Pilot Scorecard + roadmap | Score 3-5 candidate hosts. Sort high to low. Assign Phase 2-4 work to top pilot. |
| 13 | Readout prep | Executive summary (1 page). Top 3 priorities highlighted. |
| 14 | Live readout | Design + eng in the room. Decisions logged. Phase 2 kickoff date set. |
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.
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.
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)
07 · Token architecture
Primitives hold raw values. Semantics hold intent. Components never reference primitives directly.
color-blue-500: #3b5bdb
color-gray-900: #111827
space-4: 1rem
radius-md: 0.625rem
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.
Define color-text-on-action and color-action as a verified pair (4.5:1 minimum). Test both themes before you ship Button.
08 · Component priority tiers
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).
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.
09 · Patterns & the six-area model
Mature systems cover six interlocking areas. Squads ask for buttons; the expensive bugs live in regions, content, and flows.
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.
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.
10 · Phase 2 week-by-week
| Days | Build focus | Review checkpoint |
|---|---|---|
| 15-19 | Token spec + Figma variables + CSS export | Design + eng sign-off on naming doc |
| 20-24 | Button, Link, Icon, typography utilities | Demo: 3 button variants in Storybook + Figma |
| 25-31 | Full form control set | Accessibility pass: keyboard-only form completion |
| 32-38 | Alert, Badge, Card, layout primitives | Designer builds a settings card in Figma from library only |
| 39-45 | Modal, Tooltip, Tabs | Focus trap test on Modal. Screen reader spot check. |
| 46-49 | Buffer + parity fixes + publish library v0.1 | Midpoint readout: squad leads see live Storybook |
Async rhythm: Mon/Tue build · Wed WIP Loom to channel · Thu review comments · Fri merge + changelog entry.
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.
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.
12 · Connected delivery
Bootstrap is a download. Your design system should be a versioned package product teams import. Copy-paste drifts on day one.
Connected means:
npm install @your-org/design-system (or internal registry equivalent)Week 50-52 checklist:
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.
13 · Phase 3 week-by-week
| Days | Focus | Deliverable |
|---|---|---|
| 50-52 | Package + token CI | npm package v0.1 + automated token export |
| 53-56 | Code Connect / Figma links | Core components linked in Figma |
| 57-60 | Storybook + pattern recipes | Tier 1-2 documented + 1 flow recipe page |
| 61-63 | Onboarding doc | "Build your first screen" guide for new hires |
| 64-67 | Table + nav (if needed) | Tier 3 components for pilot surface |
| 68-70 | Deprecation markers | Legacy components tagged in code + Figma |
| 71-74 | Pilot squad sprint | Feature branch using system only |
| 75-77 | Merge + measure | Production 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.
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.
At least two squads shipped production features on the system. Governance RFC merged at least once. Owner can run the next quarter without you.
15 · Governance starter kit
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)
16 · Hot Potato & collaboration rhythm
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:
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
17 · Phase 4 week-by-week
| Days | Focus | Deliverable |
|---|---|---|
| 78-80 | Rollout kickoff | Squad migration briefs + deadlines |
| 81-85 | Squad 2 migration | One feature live on system components |
| 86-88 | Squad 3 migration | Second feature live |
| 89-91 | Governance docs published | RFC + PR checklist in repo |
| 92-94 | First external RFC merged | Changelog entry + comms to org |
| 95-97 | Enablement session | Recording + onboarding path updated |
| 98-99 | Metrics review | Before/after deck for sponsor |
| 100 | Handover | 90-day backlog + owner sign-off |
18 · Success metrics worksheet
Measure whether squads ship faster and happier. Component counts and doc page views are vanity metrics unless teams feel relief.
| Metric | Day 1 | Day 50 | Day 100 | Target |
|---|---|---|---|---|
| Button variants in production | 1 | |||
| Core components at Figma↔code parity | 15-20 | |||
| % pilot surface on system components | 100% | |||
| 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 surface | 0 | |||
| Package imports in product repos (count) | 2+ apps | |||
| Squad leads report "relief" (Y/N interviews) | Yes | |||
| WCAG AA failures on core components | 0 |
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."
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.
19 · Ten ways systems fail
If you recognize your team below, fix the process before you add another component.
It doesn't have to be this way. Most failures are governance and sequencing, not talent.
20 · AI guardrails
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:
color.action.primary, not blue-500)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.
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.
21 · Master 100-day checklist
| ✓ | Checkpoint | Phase |
|---|---|---|
| Pilot Scorecard completed; host squad committed | 1 | |
| Audit complete, readout done, ROI estimated | 1 | |
| Sponsor + owner named in writing | 1 | |
| Pilot surface chosen and baselined | 1 | |
| Primitive + semantic tokens in Figma and code | 2 | |
| Tier 1 components shipped with full states | 2 | |
| Tier 2 form controls + overlays complete | 2 | |
| Storybook live with core stories | 2 | |
| npm (or internal) package published; 1+ app imports it | 3 | |
| Token export automated in CI | 3 | |
| Docs: components + 1 pattern recipe (store IA) | 3 | |
| Pilot surface migrated and in production | 3 | |
| 2+ squads shipped features on system | 4 | |
| Champions named in 2+ squads | 4 | |
| Hot Potato session run; rhythm documented | 4 | |
| Canon vs expanded tiers published | 4 | |
| RFC + PR checklist published | 4 | |
| AI guardrails section in docs | 4 | |
| Enablement recorded; owner trained | 4 | |
| Day 100 metrics reviewed with sponsor | 4 |
22 · What to do next
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.
Your Phase 1 in 1-2 weeks: findings, ROI, prioritized roadmap. Fee credited toward a build.
Phase 2 delivered: tokens, core components, docs starter, Figma↔code connection. Milestone-based.
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
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 →