Most people look at insurance software and see forms, rules, pricing tables, documents. Straightforward enough. I thought so too, once.
Spend a few years building inside the industry and that impression doesn't survive.
Insurance wraps pricing, contracts, regulation, operational workflow, distribution and human judgement into a single system. Any one of those is a serious software problem on its own. But the hard part isn't any individual piece—it's that they're all coupled. Touch the rating logic and your documentation requirements shift. Reroute distribution and the operational controls have to follow. Start collecting different data and you've changed how the whole organisation understands risk, all the way downstream into reporting.
It's a stack of linked problems pretending to be one product.
If you're building software here, that has real consequences.
Accuracy matters here in a way most software categories never have to deal with.
Consumer software can get away with mild ambiguity—round a number, fudge a label, iterate later. Insurance can't. Premiums, terms, documents, auditability, downstream operational outputs: they all need genuine precision, because the product is participating in a legally and financially binding process. There's no “we'll fix it in the next sprint” when a policy has already been issued.
A pretty interface won't save you either.
In simpler categories, a good front end can paper over a lot of underlying mess. Insurance punishes that approach. Eventually the product has to deal with the actual shape of the work—the exceptions, approvals, dependencies, documentation, reporting, operational handoffs. A weak system under a polished UI is still a weak system. The work finds the cracks.
You also have to be honest about which complexity to fight.
Some of it is accidental—the result of fragmented tooling, repeated handling, unclear ownership, legacy process. Kill that complexity wherever you find it. But other complexity is inherent to the domain. Insurance genuinely involves uncertainty, differentiated products, shifting appetites, jurisdictional nuance, and decisions made under imperfect information. Good software doesn't pretend those realities away. It helps people navigate them well.
The easiest mistake I see in complex industries is assuming every rough edge means the humans are doing something wrong. Usually it's the opposite. The humans have adapted intelligently around weak systems. They've built workarounds that actually work. The product's job is to figure out where the real complexity lives, absorb what's avoidable, and properly support what isn't—without flattening the work into something that looks like a consumer app but can't do the job.
Time adds another layer entirely.
Most software cares about the present state of a system. Insurance has to care about history: how a decision was made, what terms applied at the time, how data changed, what got generated and what should be reflected downstream months or years later. Everything has to hold up under future scrutiny, which introduces governance requirements that other software markets can afford to bolt on after the fact. Insurance can't.
Distribution makes it harder still. Insurance doesn't flow through one clean channel. Different products, intermediaries, underwriting approaches and operating models each create genuinely different requirements around speed, control and information flow. You're rarely solving for a single path—you're solving for a set of related paths that still need to behave coherently as a system.
And then there's judgement, which might be the most underappreciated part. Insurance runs on expertise as much as deterministic workflow. The best operators develop real taste around risk, edge cases, market conditions—a feel for what should happen when the obvious rule falls short. You can't design the product as though everything valuable fits in a form field. It needs to know where to impose structure, where to guide, and where to get out of the way and let experienced people do their work.
Hard markets are where defensible products get built.
Difficult software categories reward people who actually understand the domain. They're brutal to enter and slow to get right, which is exactly why they're worth it. Surface-level polish doesn't get you far when the work underneath demands precision, operational depth and genuine domain knowledge.
Insurance is that kind of market. You have to care about data integrity, process design, operational detail, domain nuance and trust. You have to improve the work without condescending to the people who do it. Simplify what deserves simplifying, respect what's legitimately hard.
It's a high bar. We think it's the right one.