All work
Led designSystems at scaleDesign system2022

Evolving a design system without breaking the platform built on it.

The same playground screen split down the middle: the left half in the new light theme, the right half in the new dark theme, with header, chat, configuration panel and controls lining up across the seam.
One screen, two new themes: the same components in light and dark.
Role
Lead designer, design system
Duration
6 months dedicated in 2022, then ongoing support
Partners
Core engineering team, ~10 product designers, Language team
Result
Tokens where there were none, and one system the new platform was built on in parallel, without breaking the classic one.

Some details are simplified or withheld under NDA. I’m happy to walk through the full story in a conversation.

Context

A new platform, on a system the old one still depended on.

The company was growing, and a strategy shift meant building a new product architecture. That was the moment to modernize both the look and the experience: new color, typography and iconography, and patterns built for what the product was becoming.

The catch was that we couldn’t start from scratch. The existing system was old but extensive, and the classic platform depended on it. A clean rebuild would have been easier to design, but it would have broken a product customers were using every day.

A rebuild was off the table: the engineering cost was too high, and the system was too mature to throw away. So the constraint became the strategy. I evolved the system through new themes on the existing core, which let the new platform be built in parallel instead of waiting for a new system, and let teams already shipping features get components as they needed them.

My role

One library, one decision-maker, two platforms.

  • I owned: the Figma library, every decision on how components were built and documented, the token architecture, and the link between design and engineering.
  • I influenced: what to build next, through the shared backlog and recurring syncs with designers and engineers.

Understand before changing

Things in an old system often look wrong for a reason.

Audit. I reviewed every colour, style and pattern, and found duplicates and overlapping components that had built up over the years. Before changing anything, we traced it back to why it existed.

Listen. I surveyed ~10 designers about their pains and gains, including how they experienced our Figma files, and worked with engineers on what was failing in code. The problems fell into four kinds:

  • Figma: components that had to be detached to work.
  • Product: components that no longer covered what the product needed.
  • Engineering: legacy code too heavy to perform well.
  • Documentation: written for engineers, with no guidance for designers on which component to use when.

This gave us a short priority list, each item with a reason behind it.

Key decisions

Every change had to be safe for both platforms.

Evolve the foundation, don’t replace it. The new visual language arrived only through themes, so nothing in the classic platform had to change. Trade-off: we carried some legacy structure forward. Win: no breaking changes.

The full component sheet used to check the new theme, with a hand-drawn circle around the messages, statuses and notification popups, and an arrow to an enlarged view of that area showing info, success, warning and error variants.
The whole kit on one page. Zoom into any corner and it still fits together.

Deprecate, build or share. Each of the system’s ~50 components took one of three paths. Some were deprecated, and some were built new (the table, navigation, chat and drawer; chat came out of the GenAI work). The rest were shared by both platforms, like the date picker, and those carried the most risk: every change to them had to be checked against both platforms.

Deprecated Removed, with a path off Built new Only where nothing fit Table Chat Drawer Shared Used by both platforms Date picker trade-off zone
Every component took one of three paths.

Fix where the problem lives. Figma issues I fixed in the library. Product needs went to engineering as concrete capability requests. When a component worked but its code was heavy, we rebuilt it anyway while the work was already open.

Shared navigation for a product built in silos. The platform had grown as isolated areas with their own patterns. We designed a shared sidebar and layout and tested every area’s needs against it, because this one change touched the whole platform.

Surfaces in the shared layout: an exploded view of nine numbered surfaces in order of depth, from the app background, sidebars and main nav to the backdrop, drawer, modal and notification popup.
One layout for every area: nine surfaces, stacked the same way everywhere.

A pattern for complex flows. Nested flows, such as creating one object while in the middle of creating another, had outgrown our patterns. We didn’t just cover them; we questioned whether they could be simpler. The result was a drawer component, now used widely across the Predictive ML and Data areas.

Foundations

Accessible from the start, and named the same in design and code.

  • Tokens from zero. The system had none, only years of near-duplicate colours. I introduced a token architecture with one naming pattern for design and code.
Naming convention button primary background hover - - - component priority / type part state button badge checkbox … primary secondary tertiary background label text stroke default hover selected focused disabled success warning error Token layers Value #22272B Primitive midnight-gray-70 Contextual surface-tertiary Component card-background-default sidebarcard-background-default Themes swap at this layer.
One pattern in design and code: component, type, part, state. Each name resolves through layers down to one raw value.
  • Accessibility as a gate, not a review. AA was required before a component shipped, and an external audit later confirmed it.
A contrast table: six text colours (primary, secondary, tertiary, success, warning and error) on five dark surfaces, from surface-hover to page-background. Every pairing is 4.6:1 or higher and passes AA; primary text reaches 10.7:1 to 14.2:1, and most pairings on the darker surfaces pass AAA.
Every text colour checked on every dark surface: all pairings pass AA, and most on the darker surfaces pass AAA. The light theme went through the same check.
  • Documentation for the people choosing, not just building. The old docs were written for engineers. The new ones told designers which component to use and when, with content rules co-written with the language team.
Pages from the design system documentation, stacked: the Midnight grayscale, accent and supporting colour palettes, typography styles from heading-01 to caption, button types, and data-viz guidance for combining categorical and sequential palettes.
Pages from the system’s documentation: colour, typography, buttons, and data-viz.

Deep dive

The table: from expanding rows to master–detail.

The hardest component: sorting, filtering, drag and drop, pinned row actions, and a lot of progressive disclosure through expandable rows.

Expanding rows didn’t scale. Rows grew tall, context got lost, and density suffered. Through workshops with designers and engineers, we changed the pattern itself to a master–detail view: the table stays scannable, and details open alongside it. The hardest part was defining hover versus selected versus diving into a row, so the table behaves the same everywhere.

Not every redesign wins. For filtering, I expected a new pattern to beat the existing one. I built two prototypes, current and redesigned, and ran an unmoderated usability test with internal users on the same filtering tasks. People filtered more slowly with the redesign, so we kept the existing pattern. The system changed where the evidence said it should, not where it looked newer.

Try the component

Below is an interactive rebuild of the table, showing the behaviours the system had to get right: sorting, a filter builder, column resize, reorder, pinning, and the hover versus selected states we had to pin down. Open Columns in the top right, build a filter, drag a header, or pin one from its menu.

This isn’t the shipped product. I rebuilt a reduced version of the table from scratch for this portfolio, with its own generated sample data (model monitoring) and a smaller feature set. It shows the behaviour and states, not the exact screens.

The prototype works on larger screens.

It’s built for a desktop browser, like the tools it illustrates. Open this page on a laptop or desktop to try it.

A reduced, reconstructed table component with generated sample data.

Leading the system

Run as a product, with a backlog the whole team agreed on.

I owned the Figma library and every decision on how components were built and documented. Designers brought input; I made the call on how components were built. What to build next, we decided together. I was also the single point of contact between design and engineering. Auditing every instance of each component across the platform made me one of the few people who knew the whole product end to end.

To make the system outlast the six months, we kept a standing backlog and ran two recurring syncs, one with designers and one with engineers, where anyone could propose a pattern. At a team offsite I shared Figma usage and detach statistics, and we mapped every candidate on impact × effort with stickers on a wall. The result was a backlog the whole team had agreed on, not one I had handed them.

Designers at the team offsite placing sticky notes on a glass wall, mapping candidate patterns by impact and effort.
Data in, priorities out.

What changed

One system, two platforms, nothing broken.

  • One system, two platforms: the new platform built on new themes while the classic one kept running.
  • Tokens where there were none: one architecture and naming pattern, shared by design and code.
  • Adoption enforced in code: the core team reviewed every PR against the system and blocked those that bypassed it, so engineers adopted it first.
  • No breaking changes: issues that came up were small tweaks and missing cases, fixed quickly.
  • New platform-wide patterns: navigation, the drawer, chat, and the master–detail table.
  • A governance loop: a shared backlog and recurring syncs kept the system improving after the dedicated phase.
A staggered wall of components from the library, dark cards on a warm light background: code editor, badges, date picker, file uploader, scheduler, chat, breadcrumbs, dropdown menu, card, buttons, file tree, drag and drop, notification, slider, announcement modal, inline edit, counter and input.
From a code editor to a scheduler: one system covering the whole range of the product.

Reflection

Treat design–code sync as infrastructure, and AI as the newest consumer.

What I’d do differently. Design and code still drifted. Without today’s MCP-style tooling, alignment depended on discipline. Now I’d treat sync as infrastructure: token pipelines and code-connected components.

What comes next. Since then, engineers have started building with tools like Cursor and Claude Code on top of the system, which makes AI its newest consumer. The next iteration has to be AI-friendly, with machine-readable documentation and code tied to the repository. That would also close the drift gap. AI also brings new patterns, such as chat, citations and streaming. For each one, the question is the one every component faced: share an existing one, or build something new?

Let’s connect.

Looking for my next Principal or Staff Product Designer role in an AI-first team: hands-on, owning a product area end to end, and shaping how the team works. Happy to talk about a role, a hard problem, or design systems. I usually reply within a day.

hello@steblivets.com