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.


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.
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.

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.

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.


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.
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.



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 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.
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.


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.
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.

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.

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.


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.

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.

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.
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.





