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
- Brand color hardcoded: the old client's color stays
- Two buttons for the same job
- 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.
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
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.
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
Your benefits, 2027
Hi, Sam
| Token | Value | From |
|---|---|---|
| color.brand.primary | #1E59CD | Insurer |
| shape.radius | 10px | Insurer |
| color.brand.accent | #0096A8 | Insurer |
| brand.cobrand | none | Insurer |
| density | comfortable | Insurer |
| type.scale | 100% | Insurer |
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.
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.