What is Infa
Infa Chrome Extension
How to use and install our Chrome Extension
Community
Browse community design systems
Release Notes
Featuring the latest changes to keep you up-to-date
Research Program
Participate in shaping the future of Infa
SOC 2 Type II Compliance Badge
Enterprise Ready
SOC 2 Type II certified for enterprise-level security and compliance
EventsLearnPricing
Sign up for free

Feedback

Share your feedback

Close
Anonymous submissions are auto-posted to #feedback channel. You can also share directly in Slack.

Need help?

Reach out to contact@infa.ai or see docs

Navigation
Search...
⌘ K
Focus sentinel
Close

Search Documentation

PressESCto close
Focus sentinel
Learn
  • Playbooks
    • First 90 Days
      • Phase 1: Discovery & Orientation
      • Org Structure & Stakeholder Mapping
      • Products Map
      • Success Metrics & OKRs
      • Foundations Setup
      • Phase 2: Strategy Development
      • Communication Plan
      • Adoption Roadmap
      • Feedback Synthesis Framework
      • Phase 3: Execution & Optimization
      • Value Delivery Framework
      • Optimization Systems
      • Sustainability Planning
  • Design Systems
    • Design System Stages
    • Maturity Model
    • Process Map
    • Design System Roles
  • Insights
    • Ai Ready Documentation
    • Component Tagging Strategies
    • Interactive Documentation Strategies
    • Markdown Documentation Strategy
    • Multiple Themes
    • Props Vs Slots
  • Highlights
    • Component Classification Framework
    • Documentation Evolution Stages
    • Markdown Universal Language
    • Performance Optimization Insights
Switch to Light theme
Switch to Dark theme
TermsPrivacyChat with Us
  1. Learn
  2. Playbooks
  3. First 90 Days in Design Systems

Foundations Setup

Establish design tokens, component architecture, taxonomies, and technical infrastructure for your design system.

Timeline: Week 3-4 of Phase 1

After completing discovery (stakeholder mapping, products mapping, and success metrics), you'll start establishing the technical and organizational foundations. This work happens in parallel with finalizing your discovery deliverables.

Copy link
What Are Foundations?

Foundations are the architectural decisions, infrastructure, and organizational structures that enable your design system to scale. This isn't about building every component—it's about creating the landscape and making the right decisions upfront.

Copy link
Foundation Areas to Establish

Copy link
1. Design Tokens Infrastructure

What to Define:

  • Token architecture and naming conventions
  • Token categories (color, spacing, typography, motion, etc.)
  • Platform-specific token formats
  • Token governance model

Deliverables:

  • Token taxonomy document
  • Initial token definitions
  • Platform transformation pipeline
  • Token documentation

Tools & Decisions:

  • Token format (JSON, YAML, custom)
  • Transformation tools (Style Dictionary, Theo, custom)
  • Version control strategy
  • Distribution method

Copy link
2. Component Architecture

Component Families & Taxonomy

Organize your component library into logical families:

Example Taxonomy:

Components
├── Foundation
│   ├── Layout (Grid, Stack, Container)
│   ├── Typography (Heading, Text, Code)
│   └── Primitives (Box, Flex, Icon)
├── Inputs
│   ├── Text Inputs (TextInput, TextArea, Search)
│   ├── Selection (Checkbox, Radio, Select, Toggle)
│   └── Actions (Button, IconButton, Link)
├── Data Display
│   ├── Lists (List, Table, DataGrid)
│   ├── Content (Card, Tag, Badge, Chip)
│   └── Feedback (Toast, Notification, Alert)
└── Navigation
    ├── Menu (Dropdown, ContextMenu, MenuBar)
    ├── Navigation (Tabs, Breadcrumb, Pagination)
    └── Overlays (Modal, Dialog, Popover, Tooltip)

Component Planning:

  • Create a component inventory
  • Prioritize by usage and impact
  • Plan component families
  • Define component relationships
  • Establish variant strategies

Copy link
3. Component Research & Planning

For each component family, establish:

Research Questions:

  • Where is this component used across products?
  • What variations exist today?
  • What are the core use cases?
  • What are accessibility requirements?
  • What platform-specific needs exist?

Planning Deliverables:

  • Component spec templates
  • API design guidelines
  • Composition patterns
  • Migration strategies

Copy link
4. Product Experience Inventory

Components & Patterns Inventorization

Audit existing product experiences to understand the current landscape. This inventory becomes your source of truth for what exists, what needs consolidation, and what opportunities exist.

Using Tools for Inventory

SceneFile for Component Cataloging:

  • Catalog all components across product experiences
  • Add comments directly within product interfaces
  • Tag components for different purposes
  • Document context and usage
  • Export inventory for analysis

What to Capture in Your Inventory:

1. Component Variations Document every instance and variation:

Button Component Inventory
├── Product A
│   ├── Primary button (3 size variants)
│   ├── Secondary button (custom styled)
│   ├── Danger button (2 color variants)
│   └── Ghost button (inconsistent spacing)
├── Product B
│   ├── CTA button (completely different design)
│   ├── Link button (no hover state)
│   └── Icon button (5 size variants)
└── Recommendation: Consolidate to 4 button types

2. Things to Refactor Mark components that need work:

  • Technical Debt: Outdated implementations
  • Accessibility Issues: Missing ARIA, keyboard nav
  • Performance Problems: Heavy components, unnecessary re-renders
  • Design Inconsistencies: Off-brand colors, spacing
  • Code Quality: Duplicated logic, unclear APIs

Tag in SceneFile:

🔴 Critical refactor needed
🟡 Needs improvement
🟢 Good reference implementation

3. Component Expansions Identify where teams have expanded beyond design system:

Small Expansions (acceptable customization):

  • Custom styling for specific use case
  • Additional prop for edge case
  • Composition of existing components
  • Brand-specific theming

Example:

Component: Card
Base: Design System Card
Expansion: Added "featured" variant with gradient background
Status: ✅ Good expansion, consider adding to DS

4. Complete Deviations Document when teams built entirely custom solutions:

Good Deviations (innovation worth adopting):

  • Novel pattern solving real problem
  • Better accessibility implementation
  • Performance optimization
  • Improved user experience

Example:

Component: Data Table with inline editing
Where: Product Analytics team
Why: DS table didn't support editing
Status: ✅ Add to DS roadmap

Bad Deviations (should migrate to DS):

  • Reinventing existing component
  • Accessibility regression
  • Brand inconsistency
  • Maintainability issues

Example:

Component: Custom modal dialog
Where: Legacy product
Why: Built before DS existed
Status: 🔴 Priority migration candidate

5. Actual Component Usage Track real-world usage patterns:

Usage Metrics:

  • Frequency: How often component appears
  • Contexts: Where it's used (forms, dashboards, settings)
  • Variations Used: Which props/variants are common
  • Edge Cases: Unusual usage patterns

Data Sources:

  • SceneFile cataloging
  • GitHub code search
  • Figma component instances
  • Analytics (if available)

Format:

Component: Button
Total instances: 1,247 across 15 products
├── Primary: 623 (50%)
├── Secondary: 374 (30%)
├── Tertiary: 187 (15%)
└── Custom variants: 63 (5% - investigate)

Most common contexts:
1. Forms (45%)
2. Page headers (25%)
3. Modals (20%)
4. Other (10%)

6. Inspiration & Innovation Capture interesting implementations for future consideration:

Innovation Categories:

  • Novel Interactions: New patterns worth exploring
  • Visual Treatments: Interesting design approaches
  • Accessibility Wins: Exemplary implementations
  • Performance Tricks: Optimization techniques
  • Composition Patterns: Clever component combinations

Inspiration Board:

📌 Saved for inspiration

▪ Animated empty state (Product A)
  └── Delightful micro-interaction

▪ Progressive form validation (Product B)
  └── Better UX than current DS approach

▪ Smart table filtering (Product C)
  └── Advanced pattern for complex data

▪ Contextual help tooltips (Product D)
  └── Excellent accessibility implementation

Component Inventory:

  • Catalog all unique components across products
  • Document variations and inconsistencies
  • Identify most-used components
  • Flag redundant implementations
  • Prioritize by impact
  • Mark items for refactoring
  • Capture expansions and deviations
  • Track actual usage patterns
  • Collect inspiration and innovation

Pattern Inventory:

  • Common UI patterns (forms, tables, navigation)
  • Interaction patterns (loading, error handling, empty states)
  • Content patterns (messaging, help text, errors)
  • Layout patterns (page templates, responsive behaviors)

Inventory Process:

Step 1: Catalog (Week 3)

  • Use SceneFile to tag components across products
  • Screenshot variations
  • Add contextual notes
  • Document edge cases

Step 2: Analyze (Week 3-4)

  • Group similar components
  • Identify patterns and anti-patterns
  • Calculate usage statistics
  • Prioritize consolidation opportunities

Step 3: Classify (Week 4)

  • Tag refactor priorities
  • Mark good vs bad deviations
  • Highlight inspiration
  • Create migration candidates list

Step 4: Synthesize (Week 4)

  • Create visual inventory report
  • Present to stakeholders
  • Align on priorities
  • Feed into component roadmap

Deliverable Format:

Component Inventory Report

Summary:
├── Total unique components: 347
├── Redundant implementations: 189 (54%)
├── Migration candidates: 67 (high priority)
├── Good expansions to adopt: 23
└── Inspiration for future: 18

Top Priorities:
1. Button (12 variations → consolidate to 4)
2. Input (8 variations → consolidate to 3)
3. Card (15 variations → consolidate to 5)

Refactor Pipeline:
🔴 Critical: 23 components
🟡 Important: 44 components
🟢 Nice-to-have: 98 components

Innovation Opportunities:
▪ Advanced data table patterns
▪ Progressive disclosure components
▪ Contextual help system
▪ Animated feedback states

Tools for Inventory:

  • SceneFile: Visual cataloging and commenting
  • Figma: Component instance tracking
  • GitHub: Code search and analysis
  • Custom scripts: Automated usage detection
  • Spreadsheets: Tracking and prioritization

Copy link
5. Pattern Library Setup

Establishing Patterns:

Patterns are repeatable solutions to common problems:

Pattern Categories:

  • UI Patterns: Navigation, forms, data tables, modals
  • Content Patterns: Empty states, error messages, loading states
  • Interaction Patterns: Drag-and-drop, search, filtering, sorting
  • Layout Patterns: Dashboard, settings page, list-detail

Pattern Documentation:

  • When to use
  • Component composition
  • Accessibility considerations
  • Implementation examples
  • Do's and don'ts

Copy link
6. File Management & Organization

Figma Organization:

  • Library structure and naming
  • Component organization
  • Page hierarchy
  • Documentation approach
  • Publishing strategy
  • Version management

Example Structure:

Design System Library
├── 📦 Foundations
│   ├── Tokens
│   ├── Icons
│   └── Illustrations
├── 🧩 Components
│   ├── [Component Family Screens]
│   └── Component Documentation
├── 📐 Patterns
│   └── [Pattern Screens]
└── 📚 Guidelines
    └── Usage Examples

Repository Organization:

  • Monorepo vs multi-repo
  • Package structure
  • Component folder structure
  • Documentation location
  • Example/demo structure
  • Test organization

Example Structure:

design-system/
├── packages/
│   ├── tokens/
│   ├── components/
│   ├── icons/
│   └── patterns/
├── apps/
│   ├── docs/
│   └── playground/
├── docs/
└── examples/

Copy link
7. CI/CD Pipeline Architecture

Pipeline Decisions:

Build & Test:

  • Component build process
  • Test strategy (unit, integration, visual)
  • Accessibility testing automation
  • Performance testing

Publishing:

  • Package registry (npm, private registry)
  • Versioning strategy (semver, conventional commits)
  • Release process
  • Changelog generation

Documentation:

  • Documentation generation
  • Deployment strategy
  • Search indexing
  • Analytics

Quality Gates:

  • Linting and formatting
  • Test coverage thresholds
  • Bundle size limits
  • Accessibility standards
  • Visual regression testing

Copy link
Foundation Setup Checklist

By end of Week 3-4, you should have:

Architecture:

  • ✓ Design token architecture defined
  • ✓ Component taxonomy established
  • ✓ File organization decided
  • ✓ CI/CD pipeline planned

Documentation:

  • ✓ Component family plans created
  • ✓ Pattern library structure defined
  • ✓ Documentation approach decided
  • ✓ Contribution guidelines drafted

Infrastructure:

  • ✓ Repository initialized
  • ✓ Figma libraries organized
  • ✓ Build tooling configured
  • ✓ Initial pipelines set up

Inventory:

  • ✓ Component inventory completed
  • ✓ Pattern inventory completed
  • ✓ Redundancy analysis done
  • ✓ Priority list established
info icon
Continue to Phase 2: Strategy Development

Content Feedback

Feedback on selected content

Close
Anonymous submissions are auto-posted to #feedback channel. You can also share directly in Slack.

Need help?

Reach out to contact@infa.ai or see docs