Standardizing design for consistency and scale.

A design system built to bring consistency, efficiency, and accessibility across all LambdaTest products — turning a fragmented UI kit into the foundation for how teams built and scaled.

RoleDesign systems lead
StagePlatform
ScopeCross-productTokens → components → patterns
TeamDesign & engineering
Hours Min
Time to ship
a new screen
1 lib
Shared source
of truth, Figma → code
WCAG
Accessibility
built into components
Light / Dark
Theming from
tokens, not rewrites
TL;DRThe 60-second version+

Every LambdaTest product looked different — mismatched components, no shared tokens, accessibility as an afterthought. Designers kept recreating the same elements; developers implemented styles differently every time.

I led RetroGlitch, a design system built around reusable components, structured design tokens, a Storybook integration for engineering, and documented guidelines for how the system should be used and extended.

What once took hours — matching an existing pattern, checking contrast, rebuilding a modal from scratch — now takes minutes. RetroGlitch became the foundation for how the team built and scaled products, not just a component library sitting next to the product.

01 · Context

Every product looked different.

Inconsistent UI, mismatched components, and no shared design system. Designers kept recreating elements, developers implemented styles differently, and accessibility was an afterthought. This led to slower design, longer development cycles, and constant UI inconsistencies.

  • No design system — just a basic UI kit, components without rules, tokens, or patterns.
  • Every designer solving the same problems differently — tables, filters, empty states, and error states, all inconsistent across modules.
  • The product looked stitched together — visual language and interaction patterns shifted as you moved between modules.

Slower design, longer development cycles, and constant UI inconsistencies — the cost of no shared system, paid every sprint.

02 · Approach

Not just design — a system built to scale.

RetroGlitch wasn't a component library dropped next to the product. It was infrastructure: reusable components, a token architecture, an engineering integration, and the guidelines to keep it all coherent as the team grew.

Reusable components

Defined a shared library of buttons, forms, modals, and layouts to eliminate redundancy.

Design tokens

A structured system for colors, typography, spacing, and shadows — making theming effortless.

Storybook integration

Worked with engineers to implement Storybook, making components easily accessible for developers.

Guidelines & best practices

Detailed usage guidelines, dos and don'ts, so the system stayed coherent without me in every review.

Responsiveness principles

A seamless UI across all screen sizes and resolutions — designs that adapt to any device by default.

Iconography system

A consistent icon library to maintain visual harmony across every product surface.

03 · Inside the System

What the system actually looks like.

A look at the working parts — the search pattern, the token architecture behind theming, the Storybook docs engineers build from, and the component and icon libraries designers compose with.

RetroGlitch search and mentions component with avatars
Search — a single canonical pattern, reused everywhere
RetroGlitch design tokens — light and dark mode color variables
Tokens — one source of truth for light and dark
RetroGlitch Storybook documentation for the automation card component
Storybook — every component, dev-ready with live props
RetroGlitch action list component states and variants documentation
Component docs — states, variants, and usage guidance
RetroGlitch Figma layout grid styles panel
Layout grids — responsive structure built into the file
RetroGlitch icon library grid
Iconography — one consistent set across every product
04 · Impact

What once took hours now takes minutes.

RetroGlitch redefined how products were designed, built, and scaled — eliminating inconsistencies, streamlining workflows, and making accessibility a standard. With a shared component library, design tokens, and Storybook integration, teams worked faster and more efficiently. Light and dark mode became effortless, and WCAG compliance was built in from the start.

  • Faster design and development — standardized components and tokens reduced UI inconsistencies and sped up iteration.
  • Empowered cross-functional teams — PMs and other stakeholders could create and refine designs without relying entirely on designers.
  • Scalable and future-proof — new features and products maintained a cohesive experience with minimal effort.

RetroGlitch wasn't just a design system — it became the foundation for how we built and scaled products.

What I'm most proud of

It stopped being a component library. It became the default way to build.

The measure of a design system isn't how good the components look in isolation — it's whether people reach for it without thinking. By the end, nobody was asking "should I use RetroGlitch for this?" They were asking "what's missing from RetroGlitch that I need?" — which is a much better problem to have.