Overview
Teams across the platform were each rebuilding the same components a little differently, and the gaps were starting to show in core financial flows. I built one design system they all share — tokens, components, and the governance to keep them aligned — so teams could ship features instead of re-deciding the basics. It became the UI foundation the platform now runs on.
Context
Empower is a financial platform used by millions of people — personal finance, retirement planning, enterprise retirement. By the time I picked this up, every team had drifted into its own buttons, tables, and form patterns. Each looked fine on its own screen, but across the product the same component behaved three different ways. In money flows that isn't just untidy, it chips away at trust.
Problem
There was no shared system, so teams kept rebuilding the basics. The same table got designed from scratch on three different squads. Components behaved differently depending on who built them, and design and engineering burned most of their time arguing over details that should have been settled once. Everything shipped slower than it should have.
Key issues included
- •No shared system, so teams kept rebuilding the same components
- •The same UI behaved differently depending on which team built it
- •Design and engineering spent more time debating details than shipping
My Responsibility
I owned the design system end to end — the architecture, getting teams to adopt it, and where it went next.
A lot of the job was the unglamorous trade-offs — what looks cleanest in Figma versus what engineering can actually maintain two years out.
Solution
I built one design system the whole platform shares: tokens, components with clearly defined states, and responsive patterns. Drawing the components was the easy part. The real work was making it something teams actually adopt — so I set up ownership, a review process, and contribution rules, and treated the system as product infrastructure rather than a Figma library.
Approach
- •Audited what every team had already built and mapped what could genuinely be shared versus what had to stay team-specific
- •Put a token layer underneath everything — color, type, spacing, motion — so one change propagated instead of getting copied by hand
- •Structured components around how engineering would actually build them (states, variants, responsive behavior), not around the cleanest-looking library
- •Set up governance: who can change a component, how a change gets reviewed, and how downstream teams find out it happened
Impact
- •Design-to-engineering handoff dropped from weeks to days
- •Teams shipped features instead of re-deciding buttons and tables
- •The same UI stopped behaving three different ways across products
- •The system became the UI foundation the platform runs on today
Reflection
"The thing that stuck with me: the components were the easy part. What made or broke it was whether teams actually trusted and adopted the system — the governance, the reviews, the boring parts. Once that clicked, design and engineering stopped re-litigating the basics and got their time back for real product work."
