The Problem Hasn’t Changed
A look back at more than twenty years of creating consistency, scalability, and better developer experiences.
If someone asks me about design systems today, I usually smile. Not because I’ve spent the last few years working on them. Because I’ve been building them for almost my entire career.
Long before Figma libraries, design tokens, Storybook, or component-driven development became industry standards, I was already trying to solve the same problem:
How do we help teams build products faster without sacrificing quality or consistency?
The tools have changed dramatically.
The problem hasn’t.
It Started Before UX Had Modern Tools (2005 – 2014)
“Consistency depended almost entirely on who happened to be building that page.”
When I began my career, there was no Figma, Sketch, or Adobe XD. Most interfaces were designed in Photoshop, and developers recreated everything by hand. Every project had its own buttons, spacing, colors, forms, and interaction patterns. Consistency depended almost entirely on who happened to be building that page.
Very early on, I realized that approach wasn’t scalable. I began creating reusable front-end component libraries using HTML, CSS, JavaScript, jQuery, and centralized repositories, giving multiple teams a shared set of UI components they could build from. Looking back, they were design systems.
We just didn’t call them that yet.

TimeKeeper (2014-2015)
TimeKeeper was one of my first opportunities to introduce formalized design systems.
We worked in a Ruby on Rails environment using Photoshop before eventually transitioning into Sketch.
I implemented Bootstrap, but support inside Sketch didn’t exist yet. So, I built my own.
Instead of recreating interfaces from scratch, I created reusable Bootstrap-based UI assets that allowed designers and developers to stay aligned.
Even then, my focus wasn’t simply making screens.
It was creating systems that made everyone else’s work easier.
📒 Case Study: https://danolsavsky.com/timekeepr-a-time-and-project-tracking-app/

Stackup (2015-2016)
At Stackup, the system became more mature.
Working in Angular with UXPin, I built and maintained a customized Bootstrap design system while also developing a reusable HTML/CSS/JavaScript component library.
Unlike many design systems that stop inside a design tool, ours extended directly into implementation.
The same patterns designers created became the patterns developers shipped.
I also maintained a continuous integration process for the component library and worked closely with engineering to keep everything synchronized.
That experience reinforced an important lesson:
A design system isn’t successful because the files look organized. It’s successful when designers and developers are building from the same source of truth.
📒 Case Study: https://danolsavsky.com/designing-a-reading-analytics-platform-for-k-12-students/

T-Mobile (2017-2018)
Joining T-Mobile meant contributing to an established enterprise design system instead of creating one from scratch.
Working in Angular with Sketch, Zeplin, and InVision, I helped extend GLUE (Global Library for a Unified Experience), T-Mobile’s enterprise design system.
My work focused on expanding GLUE with components for internal applications while participating in governance reviews and contributing components back into the shared library.
It was my first experience operating within large-scale design system governance.
That taught me something new:
Sometimes leadership isn’t inventing the system. Sometimes it’s knowing how to improve it without breaking consistency for everyone else.
📒 Case study: https://danolsavsky.com/designing-a-secure-legal-data-request-platform-for-t-mobile/

Scaled Agile (2018-2025)
Scaled Agile represents the largest and most impactful design system work of my career.
When I joined the company, there wasn’t a centralized design system. There wasn’t even another product designer.
There were multiple teams solving similar problems in different ways.
As a shared product designer supporting several product teams, I had a unique perspective across the organization.
I saw the duplication.
I saw the inconsistencies.
I also saw the opportunity.
I created the first version of SALSA (Scaled Agile Library for Styling Assets), a design system based on Salesforce Lightning that supported Salesforce, WordPress, responsive web applications, and numerous third-party integrations.

As the company nearly doubled in size, our design and engineering organizations grew with it.
The design system had to grow too.
We eventually transitioned from Sketch and InVision to a modern Figma workflow supported by our new library LiME (Library for Modernized Experience), and Storybook.
The migration wasn’t just about changing tools.
It required helping an entire organization change the way it worked.
I created Figma training materials, built onboarding curriculum inside our learning management system, and helped teammates transition into new workflows.

Because I had already gone through the learning process myself, I understood where people struggled.
That made it easier to teach.
Along the way I also helped establish governance, distribution, documentation, and cross-functional collaboration across product designers, engineers, technical writers, graphic designers, and motion designers.
The system became much more than a component library.
It became a shared language.
📒 Case Study, https://danolsavsky.com/scaling-ux-and-design-systems-for-a-global-platform/
The Evolution of Design Systems
If you look across my career, the tools have changed constantly. Photoshop gave way to Sketch, Sketch eventually became Figma, static mockups evolved into interactive prototypes, and component libraries matured into Storybook, design tokens, and modern design system workflows, and AI capabilities.
What hasn’t changed is my philosophy.
Good design systems create consistency without limiting creativity. They reduce repetitive work, improve communication between designers and engineers, simplify onboarding, and help organizations scale.
Most importantly, they allow teams to spend less time rebuilding the basics and more time solving meaningful customer problems.
Looking Forward
“Helping teams create better products together will always be the real purpose of a design system.”
After spending more than two decades building products, I’ve realized that my favorite work isn’t designing individual screens.
It’s building the systems that help hundreds of people design better screens.
Whether that means architecture, governance, education, documentation, developer collaboration, or mentoring the next generation of designers, I still find the same challenge fascinating.
Technology will continue to change.
Design tools will continue to evolve.
But helping teams create better products together will always be the real purpose of a design system.



