Not a scalable, tokenised, enterprise-grade design system
Experience Design Director | 6 months
Just how I stopped every team from designing the same button 12 different ways
Crown’s design files had ballooned into monster Figma documents, loaded with overlapping components, off-brand colours, and layout decisions held together with duct tape.
Content teams were hacking pages to make things work. Devs were fielding endless design tickets and inconsistencies. Designers couldn’t find the latest source of truth, because there wasn’t one.
We weren’t just missing a design system. We were missing a shared way of working.
My Role
Made consistency look easy (it wasn’t)
I led the full lifecycle of Crown’s enterprise design system. From mapping the problem space to rolling out libraries, structure, and workflows that scaled. I also put guardrails in place to finally kill the Groundhog Day issues that kept resurfacing.
Built atomic component libraries with baked-in usage rules and responsive logic
Defined system architecture and token hierarchy that scaled across devices and brands
Set up file structures, naming conventions, and a governance model that stuck
Led QA across Storybook and Chromatic to catch issues before they hit prod
Approach
Prove it on one product, then scale it like hell
We didn’t pitch the design system as a grand vision. We pitched it as a fix. Small, measurable, and scoped. We picked one product, tracked the right metrics – design time, bugs, authoring frustration – and let the results speak for themselves.
The work was split into focused streams. We rebuilt the component set. Audited live issues across products. Created a system of brand and sub-brand tokens. Architected a file structure that worked across teams. Designed templates that could scale. Then locked in naming, QA, and handover standards to keep it all consistent.
Everything was built to prove value before asking for more. And every step forward brought another team into the fold.
Challenges
When your design system is just a folder called v4-FINAL-really
Design duplication everywhere
We audited live products, cut redundancies, and rebuilt from the token level up. Components were restructured by touchpoint and atomic hierarchy
Teams were working in silos
Design, dev, and content weren’t aligned. Naming was inconsistent, component purpose was unclear, and content often worked against the intended UX. We created shared conventions, embedded documentation, and built the system as a single source of truth across every team.
No one owned the system
We defined edit and view access, set clear roles, and created a WIP-to-release flow so updates were tracked and maintained properly.
No one wanted to invest in infrastructure
We tracked bugs, measured design and authoring time, and let the numbers make the case. Once teams saw the impact, the system sold itself.
Solution
One system, finally speaking everyone’s language
Atomic Components, Built Right
Every component used variants, auto-layout, and responsive logic—matching the live product without detaching or hacking.
Core + Sub-brand Tokens
Migrated to a token structure that allowed brand overrides without code bloat. Every spacing, colour, and font aligned across all product teams.
Component Libraries by Need, Not Org Chart
Split libraries into meaningful collections led by product touchpoint, so designers only saw what they needed.
Template Structure with Built-in Guardrails
WIP files had clear phases: research → wireframes → UI → showcase. Components were reviewed and approved before being merged into the system.
QA and Handoff Pipelines
Storybook and Chromatic helped audit visual regressions and consistency checks. Devs organised code to match the design system naming and atomic levels.
Design + Dev + Content Documentation
Each component came with built-in guidance: when to use it, how it behaves, what it inherits, and how it works for both front-end and authorship.
Results
Fewer bugs, fewer Slack arguments
98% reduction in design bugs
Design time cut by 74% for repeat features
8 sites, 1 app, and 4 brands
Shared libraries, no panic
What used to clog up Jira now barely makes it past component QA.
Teams stopped redrawing the same screen and started doing actual design.
The system scaled without snapping, bending, or requiring a thousand exceptions.
With ownership locked and rules built in, teams used the system without breaking the brand.