Insurance

Building a design system for an evolving suite of AI insurance tools

Bringing shared foundations, product patterns and implementation guidance together, so a team building across three domains could move forward without working out the same decisions in every tool.

Capabilities
Product designDesign systems
IndustryInsurance
Timeline2.5 months
PlatformsWeb and mobile

This is a white-labelled case study: a small selection of the work done for a Series A insurance startup having 5+ customer-facing enterprise tools across 3 broad domains.

What the team needed

The product engineering lead and the design lead, who worked across brand and product, brought me in as the team was building a suite of AI insurance tools.

The solutions spanned three broad domains, with multiple tools for customers to use within each. New tools were being planned and the roadmap was shifting. The system needed to support what the team was building now, while leaving room for decisions that were still taking shape.

Resolution time: switching the period updates the split, the bar and the takeaway together.
A weekly scorecard above a list of teams, with a readout for each day on hover.

We started by going through the product roadmap, the goals behind it and how the team would work across those tools. That helped frame the work: what should people recognise from one tool to another, which patterns could be shared, and where would different tasks need different behaviour?

AI was part of both sides of the problem. It appeared within the customer experience, through assistants and generated suggestions. The team also used AI to help turn designs into code. The system needed to give both kinds of work clearer boundaries.

My role was to develop the foundations, components, product patterns and supporting guidance around those needs, connecting the experience people would use with the way the team would build it.

The system’s documentation, written for the people and the AI tools building the product.
The system’s documentation, written for the people and the AI tools building the product.

Starting with what could carry across the roadmap

I reviewed the existing design and code alongside the kinds of work the tools needed to support: finding records, moving through queues, reviewing information and making changes without losing context.

Policy and claim IDs, amounts, dates and statuses appeared repeatedly, but their treatment varied across screens. Those were useful places to establish shared rules. Other decisions depended on the task. Reviewing a record and changing it could use the same underlying components, but needed different interaction behaviour.

I also looked at references for search, dense data and assistants alongside ongoing work. The useful question was how each handled a similar problem, and whether that approach made sense here.

This gave me a basis for deciding what to keep, consolidate and build. It also helped avoid making every planned feature a permanent part of the system before its role in the product was clear.

A sample from the colour audit. Established colours were pinned in place; one-off values moved to the nearest step in a shared palette.
A sample from the colour audit. Established colours were pinned in place; one-off values moved to the nearest step in a shared palette.

1. Bringing consistency without redesigning everything

There was already a product to work with. Introducing a system needed to respect the interface the team had built and the code behind it.

I used the colour audit to separate values worth preserving from small variations that had accumulated across components. Established colours were retained where they mattered, while selected one-off values were brought into a more consistent palette.

Seven colour ramps built to the same steps, so a step number means the same brightness in every colour.
Seven colour ramps built to the same steps, so a step number means the same brightness in every colour.
Atlantic, the brand blue. Each swatch shows its contrast score, step and hex; the dot marks the key step used for primary actions and focus.
Atlantic, the brand blue. Each swatch shows its contrast score, step and hex; the dot marks the key step used for primary actions and focus.

The dark, data-heavy interface needed enough range to distinguish surfaces, actions, statuses and charts. Those colours also needed clear roles. A category in a chart should not accidentally suggest a claim status, and generated content needed to be recognisable without competing with the information someone came to review.

I built the foundations around those distinctions and connected them to semantic tokens. That gave the team a shared way to apply colour as the tools developed, with fewer decisions left to individual screens or generated code.

Hover any colour for its token, hex and contrast on the card surface and on white.

Layout followed the same thinking. The tools could share a familiar workspace structure while giving different tasks the space they needed. A queue needed room to scan records and inspect one without losing position. A workspace with an assistant needed to keep the conversation and the task understandable together.

The consistency came from repeating useful relationships across the product, including where information appeared and how it behaved.

One app shell for every workspace screen: the assistant panel, top bar, page header and content area sit in the same places.
One app shell for every workspace screen: the assistant panel, top bar, page header and content area sit in the same places.
Left: the Records layout, a full-width queue with a drawer so people keep their place. Right: chart colours kept apart from status, so a category never reads as a claim status.
Left: the Records layout, a full-width queue with a drawer so people keep their place. Right: chart colours kept apart from status, so a category never reads as a claim status.
Left: the Records layout, a full-width queue with a drawer so people keep their place. Right: chart colours kept apart from status, so a category never reads as a claim status.

2. Building patterns around the work people needed to finish

I kept the underlying component set focused and put more attention into how those components worked together.

Opening a claim was one example. Finding the policy was only the beginning. The person still needed to capture what happened, enter the date, check the information and move forward. I brought those steps into a connected pattern, keeping earlier answers visible and allowing people to revisit them.

The Open Claim flow: find the policy, choose what happened, set the date, review and open. The same panel answers each question in turn.
The Open Claim flow: find the policy, choose what happened, set the date, review and open. The same panel answers each question in turn.

The missing-record state mattered just as much. A lookup can work well when the expected record exists and still leave someone stuck when it does not. I kept a way to report missing information within the flow, so the interface offered a next step at the point where the task would otherwise break down.

Opening a claim: earlier answers stay visible as the flow moves on (left), and a missing record offers a report instead of a dead end (right).

Tables needed similar care. Reviewing history, triaging a queue, editing a reserve and acting on several claims all involved rows of data. But each asked something different of the person using it.

I defined patterns around those tasks, with shared components underneath. For editing, that meant making unsaved changes visible and keeping invalid input distinct from a valid value. For bulk actions, it meant making the current selection and the actions available for it clear. Loading, empty and error states were part of the patterns too.

This was the level at which reuse became useful: the team could carry a considered interaction into another tool, with the behaviour already explained.

One table, two tasks: selecting rows shows what is selected and what can be done with it; editing a reserve keeps unsaved and invalid values visibly distinct.
Two of the four table patterns. Fixed is for read-only history; Bulk is for queues, where people reassign or export many claims at once.
Two of the four table patterns. Fixed is for read-only history; Bulk is for queues, where people reassign or export many claims at once.
Loading, empty and error, built into the table so every screen handles them the same way.
Loading, empty and error, built into the table so every screen handles them the same way.

3. Making AI’s role clear within the experience

An assistant can help someone move through work, but its interpretation should not get in the way of something the person already knows.

That distinction shaped command search. If someone entered a known command or record, the exact match took priority. An AI suggestion remained a separate, clearly marked option. Generated interpretations that could lead to an action required confirmation.

Command search: the exact match comes first, and asking AI stays a separate, clearly marked option.

The point was to preserve the person’s intent. Someone who knows what they are looking for should be able to reach it directly. Someone who needs help should be able to ask for it and understand when the response comes from a model.

I also gave AI-related content a reserved visual treatment. Its purpose was to help people recognise where AI was involved. The behaviour and wording still needed to distinguish a suggestion from a verified record or a completed action.

The assistant’s position within the workspace followed that principle. It sat alongside the task, with a visual connection to the information it affected, so people could keep track of both the conversation and their work.

The assistant sits beside the task, connected to the information it affects.
The assistant sits beside the task, connected to the information it affects.

These decisions became shared product guidance. Each new tool would not have to establish its own meaning for an AI suggestion, an exact result or an action awaiting confirmation.

4. Carrying the decisions through to implementation

The system also needed to work when AI helped write the interface.

A screen could look convincing while using hard-coded values, duplicating an existing component or missing an interaction rule. Visual consistency alone could not tell the team whether the result actually followed the system.

A pattern page in the docs. The same sections, in the same order, on every page.
A pattern page in the docs. The same sections, in the same order, on every page.

I structured the documentation around the decisions someone would need to build with: what a component was for, when to use it, how it behaved and which existing parts it depended on. Guidance stayed close to the relevant components and patterns, including keyboard behaviour, accessibility and exceptions.

I also documented specific failure modes. Search results should not move underneath someone making a selection. A generated answer should not appear to be a verified record. A tool should not invent a command because the requested one does not exist.

Left: failure modes for command search, each paired with what to do instead. Right: do’s and don’ts for Open Claim, each with a working example.
Left: failure modes for command search, each paired with what to do instead. Right: do’s and don’ts for Open Claim, each with a working example.
Left: failure modes for command search, each paired with what to do instead. Right: do’s and don’ts for Open Claim, each with a working example.

Those examples made the guidance more useful to review against. They connected a rule to something that could go wrong in the experience.

The implementation work used shared tokens and existing components where appropriate, with custom behaviour for the patterns that needed it. The aim was to give designers, engineers and their AI tools a clearer route from an intended experience to an implementation that respected it.

5. Raising the standard while the team kept building

A system also has to account for the code that already exists.

In one check, an AI-generated claim card looked plausible but failed the system’s implementation rules. That made the gap visible: a convincing first result could still need correction before it was ready to become part of the product.

An AI-generated claim card that looked right, and the same card after the checks: every value now comes from the system, and nothing new was added.
An AI-generated claim card that looked right, and the same card after the checks: every value now comes from the system, and nothing new was added.

I introduced automated checks for issues that could be identified consistently, alongside guidance for the AI tools and review for decisions that needed human judgment.

Existing code needed a different treatment from newly introduced issues. Requiring every older inconsistency to be resolved immediately would have tied adoption of the system to a larger cleanup. I established a baseline so new changes could be checked without first rebuilding everything that came before them.

That baseline did not remove the older issues. It made the starting point explicit and separated existing debt from new deviations.

The same consideration applied to documentation. An AI tool needed the guidance relevant to the task it was doing. I kept that context focused so the team could use the system in everyday work without bringing the entire documentation set into every request.

The system needed to be practical enough to use as the roadmap continued to move.

Guidance stays next to what it describes: the keyboard behaviour for Open Claim, written down so people and AI tools build it the same way.
Guidance stays next to what it describes: the keyboard behaviour for Open Claim, written down so people and AI tools build it the same way.

What the work brought together

The work established shared foundations, reusable patterns and implementation guidance for a suite of tools being developed across three domains.

Designers had more of the interaction decisions available within the system, including how to handle missing information, edits and AI suggestions. Engineering had a corresponding reference for the components, their behaviour and the rules behind them. AI-assisted work had clearer constraints and a way to identify some deviations before they became part of the product.

The system gave the team a more consistent starting point as the roadmap evolved. Shared decisions could carry across tools, while the patterns left room for the needs of each task.

The same card structure carries a trend: headline figures, a hover readout and a breakdown.

For me, the important part was deciding what needed to be agreed once, and what still needed product judgment. That balance shaped both the experience and the system supporting it.

If your team is building several products or introducing AI into an existing workflow, I’d be happy to walk you through the thinking behind this project and other work relevant to what you’re building.

Book a call

Work Showcase

More Case Studies

The Complexity Gap

You know the product and industry inside out. The people buying or using it bring different levels of knowledge and experience. The work is in making that complexity manageable throughout the product—helping beginners get started, supporting people as their needs grow, and giving experts the depth and control they need.

The Retention Gap

Getting someone to try a product is one thing. Becoming part of their day-to-day workflow is another. That comes down to how well it helps them do their job—how naturally it fits into their work, how much easier it makes important tasks, and whether it gives them a reason to keep using it.

The Growth Gap

As your business grows, the experience doesn’t always keep up.

Your brand, website and product evolve at different speeds. Some parts reflect the business you’ve become; others still belong to an earlier stage. Customers see one company, but the quality of what they see and use can leave them with very different impressions.

Your teams feel that disconnect too. Marketing works around a website it has outgrown. Product and engineering rebuild patterns that should be shared. Sales spends time explaining value the experience should already make clear.

Each workaround helps someone move forward. Together, they make growth harder to sustain.

Cursor Text