All work

White-label SaaS

Building an enterprise health-insurance platform from zero

A new client used to take weeks to set up.

With each client's brand in design tokens, it takes under a day.

Under a dayto theme a new client, down from weeks

A new client, before and after tokens

Before: hardcoded

  1. Brand color hardcoded: the old client's color stays
  2. Two buttons for the same job
  3. Rebuilt by hand for each client: weeks

With three-tier tokens

  • Color comes from the client's tokens
  • One button, from the system
  • Insurer, employer and member, themed in under a day

Illustration in a demo brand, not a client screen.

Result
Under a dayto theme a new client, down from weeks
Role
Founding UX Designer, now UX Lead
Context
Mphasis · US health-insurance platform
Timeline
Oct 2020 to now
Domain
Enterprise SaaS · US health insurance
The productOne member dashboard, re-branded live from design tokens. Every client sees it in its own brand.Animated from the design files in a demo brand.

I was asked to change a few screens

The request was small: adjust a handful of screens. This was late 2020, and I was the only designer on the product.

The product was white-label. Insurers resell it to employers, and employers show it to their members, so every level needs its own look. As I went through the screens I'd been asked to change, I kept finding the same problems underneath them.

Diagram · who sees the product

the productinsurersemployersmembersevery red box needs its own look · before: each one re-skinned by handthe productinsurersemployersmembersevery red box needs its own lookbefore: each one re-skinned by hand
One product, sold three levels deep. Every insurer and employer needs its own look, so hand edits multiply with every client.

Brand colors were written straight into the code, so nothing could be re-themed. Developers had used different components for the same job on different pages. And every new client meant re-skinning the product by hand, which took weeks.

What I was asked

Change a few screens.

Every new client made every change cost more, because there was no system underneath the product.

Sales could sign a new client, and then that client waited in line for a hand re-skin, so the business could only grow as fast as engineering could repaint the product. There was a quieter risk too. In US health insurance, an eligibility screen that behaves differently from one page to the next is a compliance risk, on top of being confusing.

I started underneath the screens

The edits were what everyone expected, and they would have shown results quickly. But they would have left every future change hand-made and every new client a rebuild.

So I started by documenting what already existed: the colors, the components and the different patterns developers were using for the same job. That document turned into the design system. Engineering felt the pain more than anyone, so they became its first users.

Each client's brand became a set of design tokens

Each client needed its own identity, and at three levels. Building a separate copy of the look for every insurer and employer would only have multiplied the mess.

So I set up three tiers of design tokens, one for the insurer, one for the employer and one for the member, and each tier overrides only what it owns. A new client stopped being a project and became configuration, and the same foundation runs web, mobile web, iOS and Android.

Three-tier theming

Setting up a new client, tier by tier

T1 Insurer

Owns brand color, shape, and logo

T2 Employer

Can co-brand: accent and logo

T3 Member

Owns personal preferences

Resolved tokens and the tier each comes from
TokenValueFrom
color.brand.primary#1E59CDInsurer
shape.radius10pxInsurer
color.brand.accent#0096A8Insurer
brand.cobrandnoneInsurer
densitycomfortableInsurer
type.scale100%Insurer
Each tier inherits from the one above and overrides only what it owns. Watch where each token resolves from.Redrawn with demo brands and illustrative data. No client screens or internal files.

Getting developers to actually use it

At first, developers carried on as before. Design tokens were still rare back then, and nobody on the engineering side was eager to work with them. The tech leads weren't against the idea, but they weren't excited about it either, and the developers weren't happy about giving up styling things directly.

So I treated adoption as part of the design work. I didn't want to lecture anyone, so I guided them instead. I'd demo it in Figma, where our tokens lived as color styles: change a style and show every screen change with it, so they could see what it would mean for them in the long run.

Checking whether they'd actually used the tokens was the hard part. There was no tool for it at the time, so I'd open inspect element in the browser and check each color by hand to see whether it pointed to a token or a fixed color. The other giveaway came when we switched a screen to a different client's brand and some colors just didn't change. Those were the hardcoded ones.

Most of these got caught in UX validation, a design check that happens before a build even goes to testing. Between the demos, the usage rules written inside the system, those checks and an agreement with the tech lead that the system is the standard, building with tokens slowly became the default.

The rest of the work ran the same way. I did stakeholder research with all three audiences and wrote three to four personas each for insurers, employers and members. New ideas went to a workshop with business analysts before any design started, so we agreed the rules first, and changes to the system were agreed with engineering before they shipped.

The Branding Hub, where admins set each client's brand

Once brands lived in tokens, someone still had to set them for a lot of employers without breaking what members see, and often several admins were working on themes at the same time. So I designed the Branding Hub, an admin tool where each client's brand is set up and checked on a real member screen before it goes out, and it's live. We haven't measured usage formally, but theming a client is now one admin task inside the system instead of an engineering job.

What changed

Theming a new client used to take weeks. Now it takes under a day, and rebranding the white-label iOS and Android apps takes one or two days. Features come in at a predictable pace, about two days of design and three of build. The library has grown past 120 components on one foundation, and it serves Fortune 500 and enterprise insurers.

Hardcoded colors and off-system components now get caught in UX validation instead of in production. To be clear, these numbers are what the team has seen, not figures we formally tracked.

The product · the library

Inside the design system engineering builds to

Theme colors are named by role, not by value: Primary, Secondary, Text, Background, each with an opacity ramp. Swap a client's brand values and every screen follows.

Four layers, from role-named tokens to whole page patterns. Each screen opens full size.Rebuilt in HTML from the design files. Demo brand; names and figures invented.

What I'd do differently

I started as the only designer on this product. Over time I grew the team to four designers, hired two of them myself, and became UX Lead. The reframe, the architecture and the adoption plan were mine.

If I did it again, I'd close the gap between the system and the people using it much earlier. Its reasoning lived in my head and in a file engineers had to remember to check. Case 03 is how I eventually closed that gap.