Methods
The site had grown faster than its design language. Patterns were copied screen to screen, the same component existed in a dozen near-identical versions, and every new page added a little more drift. I approached the design system not as a sticker sheet but as a product — with a clear strategy, an atomic structure, and rules that let it scale with the brand instead of fighting it.
Our Goals:
Consistent Design Language
One source of truth for color, type, and spacing.
Atomic Design Structure
Atoms to organisms that compose predictably.
Better UX Through Consistency
Familiar everywhere — less friction for shoppers.
Scalable & AI-Adaptive
Extends cleanly and feeds AI-assisted workflows.
Accessible by Default
WCAG AA contrast, focus, and semantics built in.
Cross-Team Adoption
Easy for marketing, growth, and engineering.
I followed atomic design as the organizing principle — tokens and primitives at the base, composed into components, then into the modules and templates teams actually ship. Naming, structure, and documentation were defined so the system reads the same in Figma and in code, and so AI tooling could generate on-brand layouts from the same building blocks rather than inventing new ones.
Impact
Page building
Self-serve
Marketing and growth assemble pages without a designer in the loop for every request
Reuse
Build once
One component serves PDPs, landing pages, and cart instead of being rebuilt per surface
Updates
Propagate site-wide
A single token or component change rolls out everywhere — no manual hunting
Handoff
Faster, less rework
Code Connect keeps design and dev in sync, cutting back-and-forth at handoff
The system turned a fragmented set of screens into one coherent product language — faster to design, faster to build, consistent for customers, and structured to scale with the brand and the tools that build it.
Tokens
Before the system, the same Dr. Squatch green lived as five slightly different hex values across the site, and spacing was whatever felt right in the moment. I started at the foundation: a single set of design tokens for color, typography, spacing, radius, and motion that both Figma and the codebase read from.
I structured tokens in layers — raw primitives (brand, accent, mono) composed into component tokens like button/primary — so a refresh means changing one value instead of hunting through every screen. The same names live in Figma variables and in tokens.css, keeping design and engineering on one language across color, type, radius, and elevation.
Components
I audited the live site and found dozens of one-off buttons, cards, and form fields that looked almost — but not quite — the same. I consolidated them into a governed component library: buttons, inputs, badges, product cards, and the marketing modules that power PDPs and landing pages.
Each component was built with defined variants, states, and responsive behavior, then documented with usage rules — when to reach for it, what to pair it with, and what not to do. Components were Code Connected to their front-end counterparts so a designer dragging in a card and an engineer importing it land on the exact same thing.
Governance
A system is only as good as the rules that keep it from drifting. I set up a lightweight governance model: a clear path for proposing new patterns, a contribution checklist, and a regular review so additions earned their place instead of accumulating.
I paired that with versioned releases and changelogs, plus office hours and quick-start docs so partner teams could adopt the system without a meeting. The result was faster, more consistent shipping — designers and engineers building from one source of truth, with brand and accessibility baked in rather than bolted on.
01
Propose
02
Review
03
Document
04
Release