Back

Apollo Design System

Apollo is a design system created to support complex B2B SaaS interfaces across different product areas, interaction states, and visual themes.

Role
Product Designer
Platform
B2B SaaS · Web
Focus
Design Systems · UI Architecture · Design–Dev Collaboration

Context / Role

I designed the system around a shared set of foundations, semantic tokens, reusable components, and usage guidelines aligned with Chakra UI.

The goal was to create a common language between design and development — one that could keep the product consistent while remaining flexible enough to evolve.

I worked across the full system — from foundations and tokens to component behavior, themes, documentation, and usage rules — while keeping the structure closely aligned with how components would be implemented in Chakra UI.

The Challenge

Creating consistency without making the system restrictive

The main challenge was finding the right balance between standardization and flexibility.

The system needed to reduce duplicated design decisions and keep interfaces visually consistent, while still supporting different product contexts, interaction states, and future requirements.

Three priorities shaped the work:

  • create a shared visual and interaction language
  • reduce inconsistencies between design and implementation
  • make components reusable without limiting product-specific needs
The balance between standardization and flexibility: shared tokens, button properties mapped to code, and a variants matrix

System Architecture

Building the system in layers

I structured Apollo as a set of connected layers rather than a flat component library.

Primitives define the raw visual values such as color, spacing, typography, and radius.

Semantic tokens translate those values into contextual roles such as backgrounds, borders, text, success, warning, and error states.

Shared components apply those rules consistently across common interactions.

Product patterns combine components into larger structures such as forms, navigation, feedback, and data-heavy interfaces.

This hierarchy allows visual decisions to evolve at the system level without requiring every component to be updated individually.

System layers: primitives, semantic tokens, shared components and product patterns

Foundations

Establishing a predictable visual language

The foundation layer defines the core visual rules used throughout the product.

It includes:

  • color primitives
  • typography
  • spacing
  • border radius and width
  • icons and illustrations

The scales were aligned with Chakra UI conventions where possible, creating a predictable relationship between design specifications and implementation.

Instead of choosing values independently for each screen, designers could work from a shared set of rules that remained consistent across the interface.

Foundations: color primitives, Inter and Wix Madefor Display type scale, 4pt spacing, radius and border widths, icons

Semantic Tokens & Theming

Designing around meaning rather than fixed values

One of the most important parts of the system was separating raw color values from their functional meaning.

Rather than assigning fixed colors directly to components, semantic tokens define roles such as:

background · border · text · success · warning · error · info

The same semantic role can then resolve to different values depending on context or theme.

This created a more scalable foundation for light and dark modes, allowing components to preserve their hierarchy and meaning without maintaining separate styling logic for each theme.

A settings card in light and dark themes, with the semantic token roles and their values for each theme

Component System

Components built as systems, not isolated elements

Shared components were designed around a consistent logic of:

variant × size × state × theme

The library includes patterns such as buttons, inputs, dropdowns, badges, selection controls, toggles, sliders, and feedback components.

Each component supports the variations required by the product while following the same underlying token structure.

This made it possible to extend components without creating one-off versions every time a new interface requirement appeared.

Component playground: variant, size, state and theme controls over buttons, inputs, dropdowns, badges, toggles and sliders

States & Feedback

Making interaction and system states predictable

For a data-heavy SaaS product, consistency becomes especially important when something changes, succeeds, fails, or requires attention.

I defined reusable visual patterns for states such as:

  • hover and focus
  • selected and disabled
  • success
  • warning
  • error
  • information
  • loading and progress

The same semantic logic is reused across inputs, badges, alerts, progress indicators, and other feedback components.

This helps users learn the meaning of states once and recognize them consistently throughout the product.

Documentation & Usage Guidelines

Making the system usable beyond the Figma library

A component library alone does not explain when or why a pattern should be used.

For key foundations and components, I documented:

  • purpose
  • variants
  • sizes
  • interaction behavior
  • usage guidelines
  • accessibility considerations

This documentation gives designers and developers context behind the component rather than only providing its visual specification.

It also helps prevent technically valid component combinations from being used in ways that create inconsistent experiences.

Button documentation: variants, sizes, do and don't examples, interaction states and accessibility checks

Outcome

A reusable foundation for evolving SaaS interfaces

Apollo established a shared framework for designing and implementing product interfaces more consistently.

The system created:

A consistent product language
Shared visual and interaction rules across different areas of the interface.

A reusable foundation
New features can build on existing tokens, components, and patterns instead of redefining common decisions.

Closer design–development alignment
The structure of the design system reflects the logic used in implementation, reducing ambiguity during handoff.

The result is a system that supports product growth without requiring the same UI decisions to be solved repeatedly.

Reflection

Building Apollo reinforced that a design system is not simply a collection of components — it is a shared set of decisions. The most valuable part of the work was defining the logic behind tokens, states, and reusable patterns so the system could stay consistent without becoming rigid.

Web & E-commerceView case Tasty Banka

Tasty Banka

A warm, brand-led e-commerce experience for a family food business, combining product discovery, storytelling, and corporate ordering.

Tasty Banka preview 1Tasty Banka preview 2Tasty Banka preview 3
  • Web Design
  • E-commerce
  • UX/UI
  • Visual Design