Design Systems

Three design systems, built from zero and kept alive.

I've built three enterprise design systems from zero: Zync at Zapp, Elevate at 3TX and YOBI at YOOBIC. Building one is the easy part. What compounds is the work after launch: maintaining, improving and scaling it as the product, the team and the strategy change.

The thesis

A design system is a product, not a deliverable

Most systems die not because they were badly built, but because nobody owned them after launch. I treat all four phases as one job — and I've done each of them more than once.

01 — BUILD

From zero

Foundations, tokens, naming conventions and the first component libraries — established where none existed.

02 — SCALE

Across surfaces

Stretching one language across consumer, ops, mobile and web without it fracturing under growth.

03 — MAINTAIN

Single source of truth

Governance, versioning, specs and QA so the system stays honest as contributors and modules multiply.

04 — IMPROVE

Through strategy shifts

Evolving the same foundations through re-platforming and new paradigms — including the AI era.

The method behind all three

Atomic Design, end to end

Every one of these systems is structured the same way — small, composable parts building up to whole screens. It's what lets the same foundations scale across platforms and survive a change of strategy.

01

Atoms

Foundations

Text styles, colour tokens, icons, shadow, border.

02

Molecules

Components

Buttons, input fields, search box, menus.

03

Organisms

Patterns

Nav bars, rating widgets, cards, KPI tiles.

04

Templates

Skeletons

The structure of a screen, page or modal.

05

Pages

Features → App

Real screens, assembled and shipped.

The three systems

Build · Scale · Maintain — in practice

Zync

Zapp · 2025 · current

Lead Product Designer — quick-commerce, real-time logistics

Stack React · React Native

Zapp is a London-born quick-commerce service — groceries, drinks and everyday essentials delivered to your door in minutes, picked from a network of local dark stores.

My current work. Zync is the system that holds Zapp's quick-commerce ecosystem together — one language stretched across two very different audiences: customers ordering in minutes, and operators running stores at high velocity. The challenge here is less "build" and more "scale and maintain across surfaces that move at different speeds."

Atomic Design

Built atomically — from colour & type tokens (atoms) up through components and patterns to full ordering and ops screens (pages) — so consumer and operational surfaces share the exact same primitives across iOS, Android and Web.

Zapp brand colour tokens — a single 50–950 scale, the atomic foundation every Zync component builds on.

New workflow · Design engineering

I build Zync's components in code — with Claude, inside Storybook — not only in Figma.

It collapses the gap between design and engineering: pixel-perfect execution with no developer interpretation and nothing lost in hand-off. I assemble entire features from real, production-grade components and demo them live from my own iPhone — showing exactly how a feature will look and behave once it ships. No more a beautiful Figma prototype that turns out only half-feasible; what stakeholders review is the real thing, running on a device.

FigmaFigma
→
ClaudeClaude
→
StorybookStorybook
→
GitHubGitHub
→
ExpoExpo · iPhone

Built

  • Component foundations spanning consumer & operational surfaces
  • Patterns for real-time, time-critical retail execution
  • Shared primitives across iOS, Android & Web

Maintained

  • One source of truth across consumer app and ops tooling
  • Consistency held while squads ship independently
  • UX strategy aligned to the broader experience principles

Improved & scaled

  • Scaling Zync to support high-velocity retail as the business grows
  • Bridging customer-facing polish with operational density
  • Multi-platform parity without duplicating the work three times
2audiences — consumer & ops — one system
3platforms — iOS, Android & Web
Livein market, maintained daily

Elevate

3TX · 2025

Lead Designer (contract) — B2B compliance & workforce competence

Stack React · TypeScript

3TX (by 3t) is a B2B platform for safety-critical industries — bringing workforce training, competence and compliance into one system so high-risk operations stay audit-ready.

The clearest "from scratch" story. 3TX was fragmented across modules with inconsistent UI and no scalable system. In parallel with redesigning the Home into an operational command centre, I laid the foundations of Elevate so the product could scale with fewer UI regressions and faster delivery.

Atomic Design

Atomic from day one — tokenised atoms → KPI tiles and dashboard organisms → Home templates, each component fully specced in Figma (anatomy, properties, variants and states) for clean dev handoff.

Elevate Figma component specs — Button anatomy, properties, variants and states
Figma component specs — Button anatomy, properties, size & type variants, and Default / Hover / Pressed / Disabled states

Built

  • Unified layout grid and spacing rules
  • Tokenised colour foundations & accessibility baselines
  • Standardised KPI tiles and dashboard components

Maintained

  • Reusable data-visualisation patterns, documented
  • Components prepared and specced for dev handoff
  • Consistency across layouts, dashboards and modules

Improved & scaled

  • Replaced fragmented patterns with one coherent language
  • Foundations designed to absorb new modules without rework
  • Faster delivery and fewer regressions as the product grows
−20%target support tickets, post-release
−30%target time-to-task vs old flow
1system replacing fragmented module UI

YOBI

YOOBIC · 2018–2025 · 7 years

Head of Product Design — enterprise frontline SaaS, 2M+ workers, 80+ countries

Stack Ionic · Angular

YOOBIC is a frontline employee experience platform — task execution, communication and mobile learning for 2M+ retail, hospitality and field workers across 80+ countries.

The deepest proof point. YOBI started as a Figma library and grew into 200+ governed components across six libraries — and I owned it through three distinct strategy eras (task platform → pandemic continuity → AI-first) on the same foundational language. That continuity, not any single screen, is the work.

Atomic Design

Atomic Design at scale — six libraries organised atoms → pages, 200+ governed components with naming conventions and accessibility baked into the foundations, so a 30+ module platform stayed coherent across seven years.

System map — one library, the whole platform

Operations Tasks · checklists · audits · forms · reports
Communication Newsfeed · chat · surveys · recognition
Learning Courses · quizzes · micro-learning · paths
YOBI — cross-platform component library 200+ governed components · six libraries · one source of truth
Web app
iOS & Android apps

One governed component library powers 30+ modules across three pillars — identical on web and mobile.

White-label — one system, every brand

YOOBIC ships as a white-label app: every retailer runs the same components, in their own brand. Because colour, type and shape live in semantic tokens, re-skinning an entire deployment is a token swap — not a redesign.

Today · 6 of 10 tasks
60%
H&M theme color.brand.primary = #CC071E
Today · 6 of 10 tasks
60%
Boots theme color.brand.primary = #1B448E

Same component, same props, same code — only the brand token layer changes. One retailer ships red, the next ships navy, on one shared YOBI system.

The 2024 rebrand shows the full stack of foundations I governed: a structured colour system (Primary · Secondary · Neutral), a dual typeface pairing — Inter for product UI and P22 Mackinac for editorial — the Flex Solid icon set, a geometric shape language, a branded illustration system (micro + macro), and research-grounded personas spanning Head of Retail to Store Associate. Note the AI-Powered button — AI patterns promoted into first-class, governed components.

YOBI colour system — Primary, Secondary and Neutral palettes
Colour system — Primary · Secondary · Neutral
YOBI typography — Inter primary and P22 Mackinac secondary
Typography — Inter & P22 Mackinac
YOBI iconography — Flex Solid icon set
Iconography — the Flex Solid set
YOBI shape language — geometry, arrows and sketches
Shape language — geometry & marks
YOBI components — buttons including AI-Powered, tags, nav bar, tab bar, widgets
Components — incl. an AI-Powered button
YOBI illustration system — micro and macro illustrations
Illustration system — micro & macro
YOBI personas — Head of Retail, OPS Manager, Area Manager, Store Manager, Store Associate
Personas — frontline to head office

And here is the system doing its job — those atoms, components and patterns composed into real frontline product surfaces:

YOBI components in production — dashboard with tasks and sales, daily priorities and calendar, and targeted update workflows
Components in production — an information hub, daily priorities & calendar, and targeted update workflows, all assembled from YOBI components.

Built

  • From no system to 200+ components across six libraries
  • Tokens, naming conventions & accessibility standards baked in
  • First principled IA — one navigation logic across 30+ modules

Maintained

  • Made it the single source of truth, with specs and QA
  • Documentation & governance to keep contributors aligned
  • Closed the 20–30% of design lost in design–dev handoff

Improved & scaled

  • Compressed a multi-quarter mobile roadmap into months — without breaking the system
  • Extended it into the AI pivot: new patterns for the NEO assistant
  • Grew the design org and craft bar around the system
200+governed components, six libraries
25%shorter onboarding for new joiners
40%training engagement on the AI assistant (NEO)

Under the hood

The mechanics every component inherits

A design system is only as good as its conventions. This is the logic I bake in so hundreds of components stay consistent, themeable, accessible and safe to change at scale — the same foundations across Zync, Elevate and YOBI.

Primitive token blue-900 = #002C3C the raw value — never used directly in a component
→
Semantic token color.action.primary → blue-900 intent — swap this one layer to re-theme everything
→
Component token button.bg.default → color.action.primary binding — the only thing the component reads

Design tokens

Three tiers — primitive → semantic → component. Re-theme the whole system by swapping the semantic layer; no component ever hard-codes a hex.

--color-action-primary

Naming conventions

Predictable, namespaced names so hundreds of components stay findable — and every Figma layer maps 1:1 to code.

Button / Primary / Large / Disabled

Component API · props

A small, typed surface — variant, size, state, slots. The Figma variant set and the code props are the same contract.

<Button variant size state icon fullWidth />

States & variants

Every interactive component ships the full set up-front, so nothing has to be improvised downstream.

default · hover · focus · pressed · disabled · loading

Documentation

Usage do's & don'ts, prop tables, accessibility notes and changelogs — so a new joiner ships without asking.

When to use · When not to · Props · A11y

Governance & versioning

Semver, a contribution model, deprecation paths and QA gates keep one source of truth honest as it scales.

v2.4.0 · deprecate → migrate → remove
Accessibility

Never bolted on at the end — WCAG 2.1 AA lives at the token level (contrast-safe pairs), with focus order, ARIA roles, keyboard paths and 44px touch targets built into every component.

AI in design work

AI as an accelerant — never the author

AI multiplies judgement; it can't replace it. The understanding has to come first — then the tools make it faster. Used the other way round, you just ship plausible nonsense at scale.

Research & synthesis

Clustering interviews, support tickets and usability notes into themes — so I spend my time on the call to make, not the transcript.

I still read the raw data

Pattern & variant exploration

Generating breadth quickly — states, edge cases, copy variants — then curating down with a human eye for hierarchy and intent.

I own the final call

Design-to-code handoff

Working knowledge of AI design-code tools to tighten the loop between Figma components and what engineering actually ships.

Specs & QA still gate it

Documentation & governance

Drafting component docs, usage guidelines and changelogs so the system stays legible — reviewed, never auto-published.

Accuracy is non-negotiable

At YOOBIC I led the exec-level conversation on where the AI assistant should suggest, decide, or stay silent — and embedded it inside the experience rather than decorating the UI with it. Knowing when not to use AI is the same skill as knowing when to.

Tools I use Claude OpenAI Linear Maze

Want to see the systems in detail?

Component libraries, documentation and screens are in the case studies, and more is available on request.

Read the YOOBIC story See Elevate (3TX)
Enlarged view