How a Midsize Insurer Found $4.2M in Hidden Friction

Coretexly Customer Team· 7 min read· June 30, 2026

A midsize insurer suspected their claims process was slower than it needed to be. Static process maps said one thing; reality said another. Handlers were working hard, cycle times were not improving, and every attempt to explain the gap ended in another workshop that produced another diagram nobody trusted.

The situation

1,200 employees across claims, underwriting, and operations
A claims platform, a legacy policy mainframe, and a growing set of SaaS tools that did not talk to each other
Months spent on process interviews that produced maps the front line quietly ignored
No visibility into the cross-app workarounds claims handlers relied on every day
An automation backlog built on guesses, with two failed RPA pilots behind it

The operations team knew the documented process was not the real one. What they could not do was prove it, measure it, or say which part to fix first.

Why the usual approach had failed

The insurer had already tried the standard playbook. Consultants interviewed handlers and drew the process. A process mining tool was pointed at the claims platform's logs. Both produced something useful and both missed the same thing: the work that happened between systems.

The claims platform logged when a claim was opened and when it was closed. It did not log that a handler left it, opened the mainframe, copied a policy number into a spreadsheet, checked coverage, and came back. That loop was invisible to the logs and absent from the interviews, because handlers had done it so long they no longer thought of it as a step.

What Coretexly found

A single lightweight deployment, no integrations and no IT tickets, observed how claims work actually happened across every application for six weeks. It revealed:

A copy-paste bridge between the claims system and the legacy mainframe, executed 1,284 times per hour across the team, each one a chance to mistype a policy number
A manual re-keying step adding 11 minutes per claim that existed because two systems disagreed on a customer identifier
Four distinct versions of the intake process running in parallel across regional teams, three of them undocumented
An exception path handled entirely by email, accounting for roughly one in five claims and most of the delay
Three SaaS tools serving overlapping functions, a secondary finding that pointed to consolidation

None of this was in the process map. All of it was in the work.

What changed

With the real process visible and every friction point quantified, the team stopped debating and started ranking. The copy-paste bridge and the re-keying step went first: high volume, low variation, fully captured context, exactly the profile that makes automation succeed. The email exception path was redesigned rather than automated, once the team could see it was a symptom of a missing field rather than a necessary step. The regional variants were standardized around the fastest one.

The automation backlog that came out of this was different from the one that preceded it. Every item carried evidence: how often it ran, how long it took, how many people it touched, and what it would return.

The result

$4.2M in identified value, mostly reclaimed handling time and eliminated rework, with license consolidation as a secondary contributor
50% faster case processing on the workflows where the top friction points were addressed
A ranked, evidence-backed automation backlog the team actually trusted, and a first agent deployment scoped on real variants rather than assumed ones
A process model that keeps updating, so the next drift is caught before it becomes the next pilot failure

We stopped guessing. We started with how work really happens. Head of Operations

Ground truth turned six weeks of confusion into a defensible plan.