NEXSUM_LABS
  1. Home
  2. Work
  3. An insurtech's three product teams started shipping from one design system
Book a call

[ Case study ]

Insurance technologyFigmaVariablesComponent libraryDev Mode handoff

An insurtech's three product teams started shipping from one design system

Three teams had shipped three interfaces that shared a brand and nothing else — different button styles, three date pickers, and inconsistent density that made the product feel assembled. Every team rebuilt the same components slightly wrong.

CLIENT an insurtech scale-up (3 product teams) — FOCUS Audit the three products into one inventory

Figma UI/UX DesignDesign & BrandingFigma UI/UX DesignInsurance technologyRepresentative example
Client
an insurtech scale-up (3 product teams)
Industry
Insurance technology
Engagement
9 weeks — experience pod — 2 designers
Service
Design & Branding / Figma UI/UX Design
Headline outcome
Component systems in use across the product, with per-team duplicates retired: 3 → 1, read from Figma library adoption audit

Representative examplesEvery case study in this library is an illustrative composite of the kind of engagement we deliver — written to show our method and standards, not to name clients.

Where they started

Three product teams — quoting, policy administration, and claims — work out of one office but have never shared a component. The company sells to mid-market brokers and has grown from one team to three in eighteen months; each team inherited a different contracting agency's front end and kept it. Design happens in three separate Figma spaces, engineering holds a small shared CSS file of variables nobody maintains, and the newest team's hires keep asking which version of a button is the real one. Nobody owns the answer.

What it was costing

Three teams had shipped three interfaces that shared a brand and nothing else — different button styles, three date pickers, and inconsistent density that made the product feel assembled. Every team rebuilt the same components slightly wrong.

What they could see

  • The same primary button shipped with three different corner radii, three hover states, and in one product, two spellings of the label.
  • New designers spent their first week reconstructing existing components from screenshots because no library file matched what production rendered.
  • Engineers rebuilt the same modal, date picker, and table components per team, so identical bugs were fixed three times at three costs.
  • QA tickets routinely came back asking whether a screen was designed or improvised — nobody could tell the difference anymore.

The constraints we worked inside

  • Three teams, three backlogs — adoption had to be cheaper than each team's status quo.
  • The existing products stayed in production; the system had to be introduced without a freeze.
  • Design tokens had to match the CSS variables the frontend already used, or engineers would fork them immediately.

What had been tried before

A previous design lead assembled a shared UI kit file and posted it in Slack with a request to use it.
It was distributed, not adopted — no one migrated existing screens, the kit's components didn't match the CSS, and each team kept its local file as source of truth.
The frontend lead consolidated the three teams' CSS into one shared stylesheet over a quiet December sprint.
Merging styles without merging components meant every team's overrides fought inside one file; the first release that broke a claims screen was reverted by Friday.
Contracting agencies were briefed to match the other products' look on new features.
Each agency interpreted the reference screenshots differently, so new screens matched at a glance and diverged on every interaction state.

What we proposed

We proposed one Figma library governed by design variables mapped one-to-one to the frontend's existing CSS custom properties, adopted team by team through real feature work rather than a migration decree. The reasoning: adoption had to be cheaper than rebuilding — if pulling a component from the library was faster than drawing a new one, the system would spread on its own. Mapping tokens to the variables engineering already maintained meant zero code changes at adoption, which removed the engineering objection entirely. Each team's next feature became the pilot: the library proved itself in their backlog before anyone asked them to trust it.

Just as important is what we ruled out, and why:

  • A full rebuild of all three products on one shared codebaseThree teams with separate backlogs couldn't absorb a parallel migration, and the products were revenue-bearing — a freeze was never on the table.
  • Adopting an off-the-shelf design system (Material, Polaris)Insurance workflows needed dense tables and unusual form patterns; re-theming a generic system to match brand and CSS variables would cost more than building from the audit.
  • Mandating the library by executive decisionA decree gets surface compliance — teams would fork the moment pressure rose; adoption had to survive deadlines, not obey them.

How the work ran

01Audit the three products into one inventory

Every button, input, and pattern across the three products was catalogued and consolidated into one component inventory — with the differences named, not smoothed over.

02Build tokens that engineers already use

Design Variables were mapped 1:1 to the frontend's CSS custom properties, so adopting the system changes no code — it changes what's drawn from it.

03Convert teams by component, not by decree

Each team adopted the shared components for their next feature, so the system proved itself in real work before anyone mandated it.

Delivered by the experience pod — 2 designers over 9 weeks, with working increments reviewed with the client every week.

The stack, and the reasoning

Figma
All three teams already lived in Figma, so the system landed in a tool with zero license cost or learning curve; the choice was really about where, not what.
Variables
Design variables mirrored the frontend's CSS custom properties one-to-one, so engineers read token names they recognized — bridging design and code without translation or a new tooling layer.
Component library
One published library with per-team visibility replaced three private files, making the shared components the path of least resistance — pulling was faster than rebuilding from a screenshot.
Dev Mode handoff
Dev Mode exposed the variables and specs engineers needed without plugin workarounds, cutting the copy-paste-from-inspector habit that had produced the drifted values in the first place.

What went wrong

Obstacle

Week six: the claims team's newest screens were built on inline hex values instead of the shared CSS variables, so the token mapping covered the older code but not the newest quarter of it.

Handled: We added an inline-style inventory to the audit, mapped the stray values back to tokens, and the senior engineer refactored the worst offenders during the claims team's pilot feature.

Obstacle

The most senior engineer reviewed the Variables structure in week six and rejected two naming decisions our mapping depended on — his constraints reshaped the token structure after it was documented.

Handled: We treated the objection as an audit finding, renamed the affected tokens, and re-published; the walkthrough cost a week but bought the engineering credibility the rollout needed.

How we worked together

Cadence
A Tuesday 30-minute component review rotated between the three teams' leads; unsettled calls went into a design-ops sign-off column in the audit inventory, where the VP of product's ruling sat beside the pattern it affected.
Client side
Each team put forward a design-owning lead and one engineer; the VP of product owned the adoption decision and shielded pilot features from scope cuts.
Decisions
Calls were made against the audit inventory — if a pattern wasn't in the library, the default was to add it there rather than improvise; exceptions needed a written reason.
They provided
Read access to all three product repos' stylesheets, four hours a week from each team's lead, and the senior engineer's time for the token walkthrough.

What changed

The headline: component systems in use across the product, with per-team duplicates retired3 → 1, read from Figma library adoption audit. A second check: design-to-build qa defects on the first three feature builds post-adoption at −40%.

The question that used to open every design review — which version is the real one — stopped being asked, because the library file finally matched production. New designers started from components instead of screenshots, and engineers stopped rebuilding the same table three times; the argument moved from pixel differences to whether a pattern deserved to exist. The three teams still argue, but they argue in the same vocabulary now, and per-team duplicates began retiring without anyone decreeing it.

The result was read from Figma library adoption audit against the pre-engagement baseline over the stated window, with a guardrail check on design-to-build qa defects on the first three feature builds post-adoption. Where platform-reported numbers and business outcomes differ, this record says which layer it is quoting.

What they own now

  • The published Figma library with component variants, documented states, and version history
  • A token-to-CSS mapping sheet the engineering team continues to maintain
  • The consolidated component inventory from the audit, kept current as patterns change
  • A contribution guide covering how teams propose and review new components
  • Recorded walkthrough sessions for onboarding new designers and engineers to the system

What we would do differently

We would have included the most senior engineer from day one — his CSS-token constraints reshaped the Variables structure in week six when it should have been week one.

Design & BrandingFigma UI/UX DesignInsurance technologyFigma

Next case study

A grocery app's checkout redesign removed the step that was costing the most carts