Prior Authorization: Why the Data Never Flows

Prior authorization is the process where a health insurer approves a treatment before it happens. It is, by near-universal agreement, one of the most frustrating experiences in healthcare — for patients waiting on care, for doctors buried in paperwork, and for the insurer staff processing it.

AI is being aimed at it from every direction, and the pitch is compelling: instant approvals, less friction, lower cost. Some of that is real. But most prior-auth AI projects underdeliver for a reason that has nothing to do with the AI. The data required to make the decision never flows cleanly to the place the decision is made.

Why prior auth is a data-flow problem

To approve or deny a treatment, you need to bring together, in one place, at one moment:

• The patient's coverage and benefit details
• Their clinical history — diagnoses, prior treatments, what's already been tried
• The specific clinical criteria for this treatment
• The provider's submitted justification, usually as clinical notes and attachments

Four data sources, from four different worlds — the payer's benefit system, the provider's EHR, a clinical-guidelines repository, and a fax or portal submission. They rarely speak to each other. So the "decision" is really an act of manually assembling scattered data, which is why it's slow, and why staff hate it.

AI that reads the same fragmented, half-missing inputs a human sees will reach the same bottleneck. The constraint was never the decision logic. It's the assembly.

The specific data failures

The clinical justification arrives as unstructured documents. The provider's rationale is clinical notes, often faxed, often scanned. The information needed to judge the request against criteria is buried in prose and images. Without extracting it into structured data, no automated decision is possible — it routes to a human to read.

Clinical history is incomplete on the payer side. The insurer sees claims, not the full clinical record. "Has this patient already tried the first-line treatment?" is often unanswerable from payer data alone, so the request bounces back to the provider — the back-and-forth that makes prior auth agonising.

The criteria aren't machine-readable. Clinical guidelines live in documents and policies, written for humans. Matching a specific request against them requires the criteria to be encoded as something a system can evaluate — which most payers haven't done.

Interoperability is theoretical. Standards like FHIR promise clean data exchange between payer and provider. In practice, adoption is partial and implementations differ, so the clean flow the standard imagines mostly doesn't happen yet.

Where AI genuinely helps — in the right order

1. Extract the clinical justification. Turn the provider's notes and attachments into structured data. This is the unlock — it's what makes any downstream automation possible, and it's a document-intelligence problem before it's a decision problem.

2. Encode the criteria. Represent clinical guidelines as evaluable rules. Now a structured request can be checked against them automatically.

3. Auto-approve the clear cases. When the extracted justification clearly meets encoded criteria, approve instantly. A large share of prior auths are straightforward and shouldn't need a human at all — freeing clinicians to focus on genuine edge cases.

4. Assemble, don't decide, the hard cases. Where it's genuinely ambiguous, the AI's job is to hand the clinical reviewer a complete, assembled picture — not to make the call. Speed comes from automating the assembly, not the judgment.

Notice the sequence puts the data work first and the decision last. Projects that invert it — starting with a decision model over unassembled data — stall immediately.

The stakes are higher here

This is healthcare, which raises the bar in two ways.

A wrong denial can cause harm. This isn't a mis-priced policy; it's a patient not getting care. The tolerance for confident-but-wrong AI is far lower, which makes explainability, human oversight on denials, and auditability non-negotiable rather than nice-to-have.

Regulation is tightening fast. Prior auth reform, transparency requirements, and interoperability mandates are all moving. AI applied here must be governed, explainable, and fair — and must handle sensitive health data under HIPAA-grade controls. Build for that from the start or rebuild later.

The honest summary

Prior authorization is a genuinely worthy target — the friction is real, the cost is real, the patient impact is real. But the reason it's painful isn't that decisions are hard. It's that the data needed to decide is scattered across systems that don't talk, arrives as unstructured documents, and is incomplete on the payer side.

Fix the flow — extract the justification, encode the criteria, unify the clinical and benefit data, keep humans on the consequential denials — and prior auth transforms. Point an AI at the mess without fixing the flow, and you've automated a bottleneck.

The pattern is the one that runs through every AI use case in insurance and healthcare alike: the model is the visible part, and the data foundation underneath is what actually decides whether it works.

We build the document extraction, data unification, and governed decisioning that health-plan automation depends on. More at IntelliBooks.