Helping smaller companies get and compare health insurance quotes on their own

Coverflex

2026

As the designer on Coverflex’s insurance product team (aka Premiums), I worked on letting companies get real health insurance prices and compare plans on their own. The comparison turned out to be a data problem before it was a design problem, and working that out took months of discovery, on and off.

What was in it for Coverflex

Insurance is a huge industry, and brokers like Coverflex earn a sizeable commission on every policy they sell. Many companies already used Coverflex for meal cards and other benefits but had no health insurance yet. Letting them get quotes on their own would start more informed conversations about insurance, and that was the most direct way to increase revenue.

The problem

A company manager wants health insurance for their team, so they reach out to Coverflex. Then the back and forth begins. What do you want covered? Who should be quoted? Family members too? Only once that's clear can our team even start getting prices. Days later, the manager gets a few PDFs back, one per insurer, each describing its plans in its own way. Which one is better? Good luck comparing.

Behind those days of waiting was a lot of manual work. The insurance industry still runs on spreadsheets, web portals and email, and there are no APIs. Coverflex’s clients are mostly small and medium-sized companies, and every quote for them was put together by hand.

So two personas were having a bad time: the manager, who waited and still couldn't compare, and Coverflex's insurance specialist team, who did the same repetitive work over and over. We wanted the manager to get real prices quickly, and to actually understand and compare what each plan offers.

We’d tried estimated prices before, and learned two things

We had tried something before. An AI assistant in the product gave managers estimated prices in a chat. People used it, but the prices weren't real. When our team then did the manual work and sent the real quotes, the numbers were different. We were mismanaging expectations.

Those chats taught us something, though. Reading what managers had asked, price came up again and again, but so did coverage: most asked about dental and about family members. And we had seen the same thing with employees. In an earlier user test, we put a prototype in front of them with three plans and asked which one they would choose. Each plan had a price and about five rows of limits, like €20,000 for hospitalisation against €25,000. But it didn't have waiting periods, fees, or anything else. It wasn't enough. They couldn't decide.

So from the start we knew two things: prices had to be real, and price alone wasn't enough.

Obstacle 1: too much manual work

Here’s what one quote looked like. A manager’s request reached Coverflex’s insurance specialists as an internal notification. Then came the back and forth. Once the company knew what it wanted, a specialist built a spreadsheet of everyone to quote, then went portal by portal, typing the same details into each insurer’s form. Doing it by hand had one upside: when a portal changed, a person could work around it. Finally, they emailed the manager the PDFs, plus a spreadsheet comparing the plans, made for that one client from a master spreadsheet. The same one we’d later start the comparison table with.

Repetitive work that humans shouldn’t have to do.

The engineering team built scrapers, programs that open an insurer's website, log in and request a quote with a specific set of options, the way an insurance specialist would. But scrapers are fragile. When an insurer changed its login or added a pop-up, the quote failed.

Still, they were good enough for a proof of concept: an internal tool for our sales and insurance teams that got real prices from insurers automatically. It wasn't perfect, but it showed this could work.

That's when our product team was called in to bring it into the product, for managers. And because we knew how fragile scrapers were, we designed for slow and broken, not only for success: each plan moved through loading, "taking longer than usual", "price unavailable, our team will follow up", and then the price.

It was also my crash course in building with AI.

Obstacle 2: price alone wasn't enough

We knew managers needed detail so they could assess if a price was worth it. What we didn't know was how much "detail" actually meant.

I'll admit it: I jumped to the solution a bit early. The questions to ask the manager looked obvious. What do you want covered, and for whom? So we started building the comparison table that answered them. Figma wasn't having it, a table this complex is painful there, so we moved to a coded prototype built with Claude. And prototypes shouldn't have lorem ipsum, so we plugged in real data: a spreadsheet our insurance specialists had built over time.

That's when the table started asking questions the spreadsheet couldn't answer. It had the plans and their main limits, but not the depth managers needed, and every insurer described its plans differently. Building the solution early showed me what was missing, which is a pretty good reason to build early.

The comparison table was a data problem before it was a design problem. You can't compare what isn't structured. Discovering what that data needed to hold became the core of the work. A coverage had three layers:

  1. The value. Not a simple yes or no. It could be not included, a discounted network (basically not included), a maximum amount, a maximum number of visits, the same limit as another coverage, covered but nobody knew how, or unlimited (very rarely).

  2. The details. A waiting period before cover started, an amount you pay first, a percentage the insurer refunds, a fixed fee per visit, and notes and exceptions.

  3. The procedures. Consultations, lab tests, scans, each with its own fee and exceptions.

A flat spreadsheet couldn't hold that. So we built linked databases in Notion, standardised across insurers: one list of plans, one list of what each covered, each plan connected to many coverages. Our insurance specialists checked the content.

Several times we stopped and asked ourselves: is this overkill? The research said it wasn't. People needed the detail. And this was real innovation in the insurance industry! So we carried on.

Obstacle 3: once plans were comparable, there were too many

So, plans were finally comparable across insurers. But pick a coverage as generic as Hospitalisation and the Portuguese market gave us 18 plans. No one is going to compare 18 plans.

So the product team set a few rules:

  1. Show real prices, straight from the insurers, with a link to each insurer's official document so managers can double-check. That's the whole point.

  2. Show only a handful of plans, so managers aren't overwhelmed.

  3. Let what a plan covers drive the choice. The AI chats showed us coverage was one of the main ways managers narrowed down their options.

  4. Let insurers compete. As a broker, we have an obligation to encourage competition.

That gave us the two cheapest plans from each insurer we had available. There were three insurance companies we were working with, so six plans: few enough to compare.

We had one more goal: upselling. It matters to us as a business, and we wanted to show more than what people asked for, like dental cover they hadn't requested. We didn't find a solution we believed in, so we left it for a future slice, where we can A/B test different strategies and see which performs better.

What the manager sees, step by step

The first screen asks what the manager wants covered.

Coverage names are jargon, and years of interviews showed us people don’t know what they include. Worse, the same name can mean different things across insurers. We simplified the hardest ones, like “dental care” instead of “stomatology”, and gave each coverage a short explanation. “Learn more” opens our AI helper with the question already asked.

Hospitalisation can’t be removed because every plan in Portugal includes it. We show it anyway, so managers know it’s there.

Insurers need everyone’s birthdate to give a price, and Coverflex doesn’t always have it. Sometimes a few people are missing one, sometimes nobody has one.

That’s why there’s a spreadsheet option. It comes pre-filled with what we have, so managers only fill the gaps. It’s also open: they can add anyone, with any birthdate. That matters because in the AI chats, 70% of the companies asking about insurance were micro companies, often a single person. Those owners may want to cover family members who aren’t on Coverflex yet. A spreadsheet lets them get a price without adding anyone to the platform first.

Family members were the other thing the chats kept raising, so including them is its own question. It’s a company policy, not an employee’s choice.

The last step is the boring bureaucratic bit. Some insurers require the company’s economic activity code, which no manager knows by heart. When Coverflex already has it, it’s shown but locked, so managers know what we’re sharing with insurers.

We also ask for a start date. It isn’t a commitment, but it changes the price. Insurers know about price changes coming, so a quote for a month from now can already include them. For a manager who’s serious about moving forward, that’s the price that counts.

The comparison

A comparison table is a lot to take in, even when the data is clean. Someone should lead the conversation, point at what matters and give an opinion. For a micro company, that someone can’t always be a person on our team. So we’re making it AI.

So the moment a manager requests a quote, an AI thread starts behind the scenes. It reads the plans and coverages from our data and starts comparing them before the prices arrive. When the scrapers bring the prices back, it already knows the plans, so it can open with the question that matters: is this worth it?

That opening line is a design decision in itself. We wrote three versions of the instruction behind it. One recommends the plan with the most cover per euro. One points out a surprising pattern in how price grows against cover. One names what the cheapest plan leaves out, and what it costs to fix. Each ends with a question, to get the manager talking.

None of this is about removing people. When a company is about to spend this much money, having a person in the conversation gives it confidence. The point of making quoting self-serve is that when a manager does reach out to us, they already know what’s possible, what it costs, and have real quotes in hand. That makes for a much better conversation.

All that discovery made the build faster

The discovery took months, on and off, because this wasn't the only thing on my plate. But it paid off.

By the time engineering started building this, most of the hard questions had answers: what a plan is, what a coverage can be, which plans to show and what happens when a price doesn't arrive. There was also a working prototype with a fully functional comparison table, built over weeks with real data. Every time I showed it to our insurance specialists, they caught something and it changed. So engineers didn't start from a spec. They started from something they could click, already corrected by the people who know insurance best. They had the context, the conversations kept flowing, and they built it quickly.

Part of this work was also reused for the Spanish market, which behaves differently in a number of ways.

What I took away

Looking back, this was the most fun I’ve ever had in discovery. I started with what looked like chaos: plans that insurers probably don’t want to be easy to compare, and a feeling that it couldn’t be done. Structuring that data, building prototypes and testing them with people who know the domain was the most enjoyable stretch of any initiative I’ve worked on.

Going deep on discovery didn't slow us down. It moved the slow part earlier, to the moment when changing your mind costs a conversation instead of a rebuild.

And the fastest way to learn a domain like insurance is to build something real and put it in front of people who know it. Every correction from our specialists made the prototype better, and made me understand the problem a bit more.

It was also my crash course in building with AI. Moving the comparison table out of Figma and into a real prototype, one that read real data instead of placeholder text, was the only way to handle that many plans, coverages and exceptions. I built it with Claude. I made a lot of mistakes along the way, and spent way too many tokens building prototypes and polishing the UI more than it needed. I still think it was worth it.

AI ended up inside the product too, leading the conversation at the comparison. But it doesn’t replace a person. When I presented this to the wider product team, a colleague put a finger on what was missing. Health insurance involves a lot of money, and some managers will always want to talk to someone before deciding. Right now, they can’t easily reach a person without choosing a plan first. Making a human easy to reach right at the comparison, even with AI already there, is the next problem.

One question stayed with me, though. We built this data once, and people reviewed it. But insurers change their plans and what comes with them, sometimes every month. How do you keep data like this from going stale?

©

2026

Luís Carmona. All rights reserved.

Built using Framer, Claude and some tricks up my sleeve.
Brush your teeth at least twice a day.

©

2026

Luís Carmona. All rights reserved.

Built using Framer, Claude and some tricks up my sleeve.
Brush your teeth at least twice a day.