15 Design System Examples: Material, Polaris & Carbon

Vincent13 min read ·

15 Design System Examples: Material, Polaris & Carbon

The best design system examples include Google Material Design, Shopify Polaris, IBM Carbon, Atlassian, Adobe Spectrum, and Microsoft Fluent. They demonstrate how reusable UI components, design tokens, and consistent design principles help teams build scalable digital products. Explore these best design systems to understand how established teams organize their visual foundations.

However, creating a design system that works in practice is harder than collecting attractive UI components. Poorly organized tokens, inconsistent visual styles, fragmented design assets, and disconnected workflows can make even well-designed systems difficult to maintain as products grow. Learning how to create a design system can help teams establish a more structured approach from the beginning.

Virse makes visual design exploration easier with an infinite canvas and multiple AI models in one creative workspace. You can explore different visual directions, use reference images, generate and edit visual assets, and organize creative ideas without constantly switching between tools. With unlimited seats and unlimited model usage on paid plans, Virse gives creative teams more room to experiment and develop consistent visual directions. You can also use the AI Design System Generator to explore and develop design-system concepts. Start creating with Virse and turn your design inspiration into polished creative assets.

Design System Builder

15 Best Design System Examples for UI and Product Design

These 15 examples cover different approaches to visual foundations, reusable components, accessibility, documentation, and product workflows. They are selected for their learning value, not presented as an objectively ranked performance list.

Comparison infographic highlighting 15 design system examples and six implementation case studies covering adoption, tokens, migration, and governance.
  1. Google Material Design: Best for Visual Foundations

Material Design is a comprehensive reference for color, typography, layout, motion, and reusable interface components.

What to study:

  • Design principles and visual foundations.
  • Color systems and semantic color roles.
  • Reusable components and interaction patterns.
  • Adaptive layouts across different interfaces.

Practical takeaway: Establish visual principles before building individual components. Adapt Material's approach to your brand instead of copying its visual identity. Its greatest learning value is understanding how consistent design foundations influence an entire interface.

  1. Shopify Polaris: Best for E-Commerce Design Systems

Polaris focuses on merchant-facing workflows and reusable patterns for commerce applications.

What to study:

  • Task-oriented interface components.
  • Consistent patterns for operational workflows.
  • Content and interaction guidance.
  • The relationship between design foundations and product requirements.

Practical takeaway: Build components around actual user tasks rather than creating a collection of visually attractive but disconnected elements. Commerce interfaces need to make frequent operational activities understandable and consistent.

  1. IBM Carbon: Best for Enterprise Design System Documentation

Carbon is particularly useful for studying component documentation, theming, accessibility guidance, and enterprise interface patterns.

What to study:

  • Component usage instructions.
  • Reusable design foundations and themes.
  • Documentation connecting design decisions with implementation.
  • Consistent patterns for complex applications.

Practical takeaway: Every reusable component needs more than a visual example. Document its purpose, states, behavior, and limitations. This is particularly important when multiple teams share the same system.

  1. Atlassian Design System: Best for Component Organization

Atlassian provides a useful reference for organizing components and design patterns across collaboration products.

What to study:

  • Consistent component naming.
  • Structured documentation.
  • Reusable workflow patterns.
  • Design consistency across related products.

Practical takeaway: Clear naming reduces misunderstandings between designers and developers, particularly when products contain many related components.

  1. Adobe Spectrum: Best for Creative Application Interfaces

Spectrum demonstrates how a shared design language can support complex creative applications.

What to study:

  • Semantic design decisions.
  • Visual hierarchy and color foundations.
  • Reusable interface components.
  • Consistency across creative workflows.

Practical takeaway: Creative products need consistent controls without sacrificing flexibility for specialized tasks. A shared visual foundation should support different workflows rather than restrict them.

  1. Microsoft Fluent 2: Best for Cross-Platform Design

Fluent 2 provides a useful reference for adaptive interfaces and shared design foundations across platforms.

What to study:

  • Global and alias token concepts.
  • Typography and color foundations.
  • Platform-aware components.
  • Theme organization.

Practical takeaway: Separate foundational values from semantic roles so design decisions can be reused across different environments.

  1. GitHub Primer: Best for Developer-Focused Products

Primer offers a reference for building consistent interfaces around developer workflows.

What to study:

  • Reusable component foundations.
  • Developer-oriented documentation.
  • Explanations of design decisions.
  • Consistent patterns for technical products.

Practical takeaway: Documentation should explain not only how a component looks, but also why and when developers should use it. This makes design decisions easier to understand and implement.

  1. Uber Base: Best for Scalable Product Interfaces

Uber Base connects design foundations, components, patterns, and specialized extensions across product experiences.

What to study:

  • Shared visual foundations.
  • Reusable components.
  • Product-specific extensions.
  • Consistency across different user experiences.

Practical takeaway: A scalable system needs a consistent core without forcing every product into identical workflows.

  1. AWS Cloudscape: Best for Enterprise UI Patterns

Cloudscape is a useful reference for operational interfaces and information-heavy applications.

What to study:

  • Complex interface patterns.
  • Reusable component guidance.
  • Enterprise workflow organization.
  • Patterns for presenting operational information.

Practical takeaway: Design reusable patterns around real information requirements rather than focusing exclusively on individual UI elements.

  1. eBay Playbook: Best for Brand Documentation

eBay Playbook is worth examining as a reference for brand expression and design documentation.

What to study:

  • Brand-specific design guidance.
  • Documentation structure and navigation.
  • Visual consistency across digital experiences.

Practical takeaway: A design system should preserve brand recognition while making product interfaces easier to maintain. Brand guidelines and reusable interface foundations should work together.

  1. Nordhealth: Best for Specialized Product Systems

Nordhealth provides another perspective on organizing design and development resources for specialized products.

What to study:

  • Reusable design foundations.
  • Component documentation.
  • Design-to-development organization.

Practical takeaway: Evaluate how a system supports its actual product context instead of assuming that a general-purpose library will fit every industry.

  1. Apple Human Interface Guidelines: Best for Native UX Patterns

Apple Human Interface Guidelines (HIG) focuses on platform conventions and interaction guidance rather than functioning as a conventional cross-platform component library.

What to study:

  • Native navigation patterns.
  • Platform-specific interactions.
  • User expectations and interface behavior.
  • Consistency with established platform conventions.

Practical takeaway: Reusable design should respect the environment in which people interact with a product. A web application and a native mobile application do not necessarily need identical interaction patterns.

  1. Ant Design: Best for Enterprise Components

Ant Design is a useful reference for applications involving forms, tables, dashboards, and complex workflows.

What to study:

  • Structured component libraries.
  • Data-heavy interface patterns.
  • Consistent forms and interaction elements.
  • Reusable enterprise components.

Practical takeaway: Prioritize frequently reused components before expanding into specialized patterns. This makes a component library more practical to adopt and maintain.

  1. Adobe React Aria: Best for Accessible Components

React Aria provides accessible interaction components and foundations rather than a complete branded design system.

What to study:

  • Keyboard interaction.
  • Accessibility behavior.
  • Separation of interaction logic from visual styling.
  • Reusable interaction foundations.

Practical takeaway: Accessibility should be part of component architecture, not an adjustment made after visual design is complete. Separating behavior from appearance also gives teams more flexibility when creating branded interfaces.

  1. Wise Design System: Best for Product-Specific Design Language

Wise is another useful reference for examining how a recognizable product identity translates into digital experiences.

What to study:

  • Brand expression.
  • Product consistency.
  • The relationship between visual foundations and user workflows.

Practical takeaway: Evaluate a design system within its product context. Do not assume that every successful visual approach can be transferred unchanged.

Material vs Polaris vs Carbon: Which Design System Should You Study?

Material, Polaris, and Carbon demonstrate three different approaches to design-system development.

Criteria

Material

Polaris

Carbon

Primary focus

Visual foundations

Commerce workflows

Enterprise interfaces

Key learning area

Color and principles

Task-oriented components

Documentation and theming

Suitable reference

General product design

E-commerce products

Complex applications

Main consideration

Brand adaptation

Business-specific patterns

Documentation complexity

There is no universal winner. Study Material when you need stronger visual foundations, Polaris when your product revolves around operational workflows, and Carbon when documentation and enterprise consistency matter most.

For a small SaaS team, studying all three can be more useful than adopting any one system wholesale. Extract the principles that solve your actual product problems rather than reproducing an entire established system.

Design Tokens Examples: How to Organize Colors, Typography, and Spacing

Design tokens are named, reusable values representing design decisions, including colors, typography, spacing, borders, and component properties.

Instead of assigning individual values throughout a product, teams reference shared tokens. This creates a consistent relationship between design decisions and production interfaces.

Primitive, Semantic, and Component Design Tokens

A practical token architecture can use three organizational layers.

Token Layer

Example

Purpose

Primitive

blue-600

Stores a foundational value

Semantic

color-action-primary

Defines design intent

Component

button-background-primary

Applies a value to a component

For example, a primary button can reference a semantic color token, which maps to a primitive color. When the brand palette changes, the underlying mapping can be updated without manually changing every button.

Primitive tokens store values, semantic tokens describe intent, and component tokens apply those decisions to specific interface elements.

Not every design system requires all three layers. The architecture should reflect product complexity and the number of teams maintaining it.

Three-layer design token architecture showing primitive, semantic, and component tokens with a blue color mapping example.

Color, Typography, and Spacing Token Examples

Category

Example Token

Purpose

Color

color-text-primary

Main text

Color

color-background-primary

Main background

Typography

font-size-body

Body text

Typography

font-weight-semibold

Emphasis

Spacing

spacing-small

Compact gaps

Spacing

spacing-large

Larger layout gaps

Radius

radius-medium

Component corners

These are illustrative naming examples, not verified token values extracted from the featured brands.

How Token Naming Prevents Development Rework

Our research identified token naming and architecture as recurring implementation challenges.

One independent developer described rewriting icon variables twice while organizing a Vanilla CSS design system. The same implementation experience involved Web Components and CSS scroll-snap.

A practical solution is to establish naming conventions before the component library expands.

  • Separate foundational values from semantic roles.
  • Use consistent category and naming structures.
  • Avoid creating multiple tokens for the same design purpose.
  • Document relationships between tokens.
  • Define how changes affect existing components.

Poor naming is not simply a documentation problem. It can create repeated development work and make future updates harder to manage.

Real Design System Case Studies: Six Implementation Lessons

Our research reviewed practitioner accounts involving adoption, component maintenance, design handoff, token organization, and version management.

These are individual implementation accounts, not independently audited industry statistics. Their value lies in the concrete problems they reveal and the practical lessons that design-system teams can apply.

Case 1: Design System Adoption Across Six Companies

A product manager described unsuccessful design-system implementations across six companies.

The recurring problems included:

  • Component updates breaking existing interfaces.
  • Slow delivery of requested components.
  • Insufficient maintenance resources.
  • Teams working around shared systems.

What this reveals: Building a component library does not guarantee adoption. A system needs clear ownership, engineering support, change management, and ongoing maintenance.

Design system implementation challenges reported across six companies, including broken updates, slow component delivery, insufficient maintenance, and low adoption.

Case 2: A Startup Team With 1–2 Designers and 1–2 Engineers

A startup-oriented design discussion involved 1–2 designers and 1–2 engineers evaluating Radix, MUI, and Material Tailwind.

The team wanted to improve an inconsistent Figma workspace. Its evaluation concerns included visual differentiation, dark-mode support, and component coverage.

What this reveals: Small teams should evaluate design flexibility, Figma resources, implementation compatibility, and maintenance requirements before adopting a large system.

The important decision is not how many components a library offers, but whether its components solve the team's actual problems.

Case 3: Figma Delivery Without Developer Adoption

An Angular-based multi-site implementation exposed a disconnect between design delivery and development.

The designer had delivered a design system, but developers continued working without adopting it. Angular and DevExpress were part of the implementation context.

The available account did not establish a completed migration or measurable adoption result.

What this reveals: Design-to-code handoff needs an acceptance process. Both teams should agree on component names, states, implementation responsibilities, and QA requirements.

Case 4: Token Architecture Rewritten Twice

An independent developer described rewriting icon variables twice while organizing a Vanilla CSS design system.

The implementation also involved Web Components and experimentation with CSS scroll-snap.

What this reveals: Token naming and architecture should be planned before the system expands. Foundational variables that are poorly organized can create repeated implementation work.

Case 5: A Nearly Two-Year Version Migration Misinterpreted

A design-system maintainer described a newer Figma component version introduced nearly two years earlier.

Older components continued appearing in usage data, initially suggesting that migration had not succeeded. Further investigation revealed that users were copying older tables rather than necessarily choosing outdated components.

What this reveals: Component usage counts need behavioral context. High usage of an older version does not automatically prove that users are rejecting migration.

Teams should investigate how components enter files and how people reuse existing assets before deciding that an adoption problem exists.

Timeline showing a nearly two-year Figma component migration and the discovery that older table reuse affected usage metrics.

Case 6: Enterprise Design System Planning With Cross-Functional Teams

An enterprise team planned its design system with four people: two designers and two senior developers.

It considered Ant Design, Carbon, and Material as references while addressing legacy interface requirements.

A separate design-team discussion involved five UX designers exploring Figma, Tokens Studio, and Git for design-system management.

Neither account provided a verified business outcome.

What this reveals: Design-system governance is a shared responsibility. Designers, developers, and product teams need agreed processes for documentation, versioning, and component updates.

Comparison of startup and enterprise design system team structures, showing designer and engineer counts and a separate five-person UX team.

How to Choose the Right Design System for Your Team

The best design system depends on team size, product complexity, technical requirements, and maintenance resources.

Team or Project

Recommended References

Main Priority

Early-stage startup

Material, Polaris

Essential foundations

E-commerce SaaS

Polaris

Merchant workflows

Enterprise application

Carbon, Ant Design

Documentation and complex components

Developer product

Primer, React Aria

Developer usability and accessibility

Cross-platform product

Fluent 2, Material

Adaptive foundations

Brand-focused product

eBay Playbook, Spectrum

Visual identity and consistency

Before adopting a system, evaluate five areas:

  1. Component coverage: Does it support your actual product workflows?
  2. Token architecture: Can colors, spacing, and themes be maintained consistently?
  3. Design-to-code alignment: Can Figma components map clearly to production implementations?
  4. Accessibility: Are keyboard interactions and component states documented?
  5. Governance: Does someone own updates, documentation, and maintenance?

A smaller, well-maintained system is often more useful than an extensive library that nobody consistently adopts.

Frequently Asked Questions

What are the best design system examples?

Material Design, Shopify Polaris, IBM Carbon, Atlassian, and Microsoft Fluent 2 are useful references. Each demonstrates different approaches to visual foundations, component organization, documentation, and cross-platform consistency.

What is the difference between design tokens and UI components?

Design tokens define reusable values such as colors, typography, and spacing. UI components are interface elements that use those values, including buttons, cards, forms, and navigation. Tokens establish shared foundations, while components apply them to product interfaces.

Should startups build or adopt a design system?

Startups should evaluate existing systems before building everything from scratch. A small team can begin with essential components and customized tokens, then expand as product requirements and engineering resources grow.

How do you measure design system adoption?

Measure component usage, implementation consistency, migration progress, developer feedback, and maintenance quality. Interpret usage data carefully because older components may remain in files due to copying behavior rather than deliberate rejection of newer versions.

Conclusion

The best design system examples offer more than reusable UI components. Material demonstrates visual foundations, Polaris provides workflow-oriented patterns, and Carbon illustrates documentation and enterprise organization. The other examples offer valuable lessons in branding, accessibility, developer experience, and component architecture. Our research also highlights a critical implementation lesson: token architecture, developer adoption, version management, and clear ownership determine whether a design system remains useful over time. Study established systems, select the patterns your product actually needs, and build a maintainable foundation that connects design decisions with production code.

More from the Virse Blog