Most software sold into insurance makes one step faster. That's useful, but it's the wrong unit of progress. The industries that actually transform do so when the operating model becomes software-native — when the logic of the business lives in code, not in the duct tape connecting forty tools together.
Insurance hasn't made that shift yet.
There is no shortage of software. Underwriters have quoting tools. Binders feed into policy admin platforms. Bordereaux get assembled in spreadsheets that talk to accounting systems through some unholy combination of CSVs, email attachments and manual re-entry. Each piece might be perfectly fine on its own. The problem is the seams — every handoff between systems is a place where data gets retyped, context gets lost and someone's afternoon disappears into reconciliation work.
I've watched experienced operators spend more time maintaining continuity between systems than doing actual underwriting. That's an expensive failure, and it's a structural one. You can't fix it by buying another tool.
The phrase I keep reaching for is operating system. I don't mean it literally. I mean a coherent software layer underneath the daily work — a shared structure that governs how information, rules, decisions and outputs behave across the full life of a product. Something that makes the business legible to itself.
What would that actually take?
A reliable model of the work itself.
Think about what happens when a submission arrives. The risk gets structured, priced, maybe negotiated, bound, documented, loaded into admin, reflected in bordereaux and reporting. Every step depends on the fidelity of the one before it. When the system can't preserve that chain, people reconstruct it manually — and you pay for that in ways that never show up on a P&L line.
Less translation between systems.
One of insurance's hidden taxes is the effort spent converting information from one shape to another. A quote gets built in one tool, the schedule wording gets assembled in Word, the bind details get re-keyed into a policy admin system, and then someone pulls it all back out again for the bordereaux. Every touchpoint is a chance for delay, error and drift. A stronger core keeps everything grounded in the same source of truth so the data moves but the format doesn't.
Room to change without breaking everything.
Rating logic changes mid-year. A new capacity provider wants different reporting fields. The distribution model shifts and suddenly you need three quoting workflows where you had one. If your systems can't absorb that kind of change without a six-week project and a lot of nervous testing, you're strategically stuck. Doesn't matter how good your people are.
Visibility that comes for free.
Nobody should need a two-week archaeology project to answer “how many quotes did we decline last month and why?” When the system is well-built, that kind of visibility falls out of the work naturally. It's a byproduct, not a reporting exercise assembled after the fact by someone who wasn't in the room.
Point solutions can't fix this. You can speed up a quoting screen. You can automate a document template. Those are real improvements. But if the underlying model stays fragmented, you're just moving the complexity around. You solve the bottleneck in quoting, and it reappears in bind processing. You clean up bind processing, and the mess migrates to bordereaux. The water finds the cracks.
Insurance feels this more acutely than most industries because the chain of dependencies is so tight. Rating drives documentation. Documentation drives service. Operational accuracy drives reporting. Reporting shapes your relationships with capacity providers and regulators. A single weak link propagates in every direction, which means a more coherent core compounds in value fast.
There's an organisational cost too, and it's an insidious one. When systems are brittle, institutional knowledge migrates out of the infrastructure and into people's heads. Karen in operations knows which bordereaux fields the Lloyd's syndicate actually validates. James knows the workaround for the rating engine bug that nobody ever fixed. That knowledge is valuable, but it's also fragile. People leave. People get sick. And suddenly you discover that what looked like expertise was really just a human patch over a systems failure.
Growth makes all of this worse. Double the GWP and you don't just double the handling — you get a combinatorial explosion of edge cases, workarounds and operational strain on scaffolding that was creaking at half the volume. A real operating system doesn't eliminate the need for judgement. It frees your best people to exercise judgement instead of spending their days stitching systems together.
Then there's AI. The businesses that get real value from AI in insurance won't be the ones who drop a language model into a chaotic process and pray. They'll be the ones whose architecture is clean enough for AI to actually work with — where information is well-structured, workflow states are legible and the boundaries around automated decisions are clearly drawn. You can't bolt intelligence onto incoherence.
AI works better when the operating system is better.
The next phase of insurance software won't be defined by feature lists or demo polish. It'll be defined by coherence — by who helps insurance businesses run on a fundamentally stronger model from submission through to settlement.
Insurance doesn't need more software. It needs better foundations.