Case study · 8 min read

How I rebuilt a SaaS design system

The library still lived in Sketch. Fifteen poorly structured parts. Docs behind a VPN, so people stopped opening them. I rebuilt it as a token-driven Figma system and treated it as an internal product, with customers, a backlog, and a way to tell if a component was actually ready.

FieldDetail
RoleProduct designer. Architecture, tokens, governance, delivery. Team of two.
Built withFigma, auto layout, variants, semantic tokens, in-file documentation.
Runs asOne library for a SaaS sales platform covering the full sales cycle.
StatusShipped. Contribution model, health dashboard, and a queue instead of side files.

Three jobs, in the order the work actually failed:

  1. 01 Mature the library. Grow one thin Sketch file into a token-driven system.
  2. 02 Fix the user journey of the system itself. Designers and engineers had to find parts without a VPN and a scavenger hunt.
  3. 03 Make delivery predictable. Alignment could not be a meeting. It had to be a process.

The library was leftover

When I joined, the design component library was a holdover. Sketch in a Figma shop. No more than 15 components, poorly structured. Documentation lived on a custom site that needed VPN. That one constraint did more damage than the missing parts. People stopped being users of the system.

The work was not a nicer kit. It was to make the good path cheaper than a custom file.

My role

Two of us. I owned the end-to-end ecosystem: architecture and roadmap, alignment with product and engineering leadership, governance and adoption, delivery operations.

Treat the system as an internal product. It has customers. It needs a backlog, a health check, and support. A library with no operating model is a folder.

Semantics and design tokens

The legacy system used hard-coded hex. Global change was a find-and-replace. Theming was a fantasy. I started with an audit, not a palette:

  • Took every component apart and named what it was for, not what it looked like.
  • Wrote a semantic naming framework around purpose and meaning, so picking a value was a design decision, not a guess.
  • Implemented tokens for color, typography, spacing, elevation, border, radius, and breakpoints.
  • Made token usage the shared language between design and engineering.

Components

I rebuilt the library on current Figma, not a port of the Sketch file:

  • Auto Layout and constraints so parts kept their behaviour when the content changed.
  • Variants and properties for every supported state, instead of a stack of nearly-identical frames.
  • Interactive components, so testing sessions used the real object, not a picture of it.

I also wrote the rule for when to keep one component and when to split it. Button was the test. Primary, secondary, negative, ghost. 862 variants in a single component. Search returned Button. Designers guessed. Splitting by type made picking a decision, not a hunt.

Documentation

I read public systems for structure, not for decoration. What I kept: clear instructions, a repeating page shape, and guidelines people could act on. VPN docs had already trained the team to skip reading. The new pages had to live where the work lived.

Every component got the same frame:

  • Anatomy
  • Behavior
  • Usage and content
  • Do / Don't
  • Accessibility

The guides sit in Figma because that is where people already were. A prettier site they cannot reach is not documentation.

Templates and patterns

Atomic design looked clean on a whiteboard. We had three files: Components, Modules, Layouts. Then the arguments started. Why is a modal a component if it is made of smaller units, and a sidebar a module? The taxonomy was serving the framework, not the product.

I restructured around real CRM use:

  • Merged components and modules.
  • Replaced Layouts with templates for the patterns the product actually repeats: dashboards, tables, boards, forms.
  • Built a pattern library for the UX problems that kept coming back, so teams stopped solving empty states from scratch.

Governance and advocacy

Stakeholder strategy

I started with interviews, not a rollout deck. Designers, engineers, the people who had already given up on the old library. Then a workshop to name the actual blockers. Scope and lifecycle were the loudest: nobody could tell if a component was ready, documented, or in code.

I built a System Health dashboard. Every component, three vectors: Figma readiness, documentation, code coverage. If it was red, it was not in the system yet, no matter how finished the file looked.

Shared ownership

A private roadmap is how a system becomes someone else's problem. I put a vote on the backlog so designers could rank what hurt. People contribute to a list they can move.

Leadership alignment

With product owners, the design director, and the VP of product, the system stopped being a side project. It sat in the same planning conversations as the product it was supposed to serve.

Project management

I took the ops. Jira space, slices, owners, dates. Planning that named the work instead of hoping two people would stay aligned by proximity.

The shift that mattered: the system is a product. It has users. Growing is easy. Pruning, queueing, and refusing the extra variant is the job.

Multi-tenant design system →Supply chain platform →