HEALTHCARE IT NEWS & BLOG
The Coding Game Is Over. Most Payers Haven’t Realized It Yet.
For years, payer growth was driven by how well risk was documented, not how well it was managed. That model is breaking. As pressure builds from regulators, rising costs, and outcomes, coding is no longer the strategy, it is the baseline. The real shift is underway, and it forces a harder question: can payers move beyond capturing risk and actually change it?
For years, payers found a reliable way to grow.
Document more.
Code better.
Capture more risk.
It worked so well that entire operating models were built around it. Vendors scaled. Teams expanded. Technology followed.
Revenue didn’t just come from managing health.
It came from how well you described it.
That model is now breaking.
And most organizations are still playing by the old rules.
What’s changed isn’t subtle.
Oversight on risk adjustment is tightening.
Payment pressure is increasing.
Medical costs are accelerating faster than premium growth.
The result is simple.
You can’t code your way to growth anymore.
This is where the disconnect starts.
Most payer organizations are still optimized for documentation, not outcomes.
They are built around:
Retrospective chart reviews
Coding audits and vendor programs
Documentation capture strategies
All of it designed to make sure nothing is missed.
But nothing about that model actually improves the health of a member.
It just improves how the condition is recorded.
That distinction didn’t matter as much before.
Now it does.
Because growth is shifting.
Not from how well you capture risk.
But from how well you manage it.
And that’s a completely different capability.
It requires identifying risk earlier.
Intervening in real time.
Closing care gaps before they turn into cost.
That’s not a coding function.
That’s operational execution.
Here’s the problem.
You can’t take a system designed to look backward
and expect it to perform looking forward.
The workflows don’t match.
The incentives don’t align.
The infrastructure isn’t there.
And yet, many plans are still trying to stretch documentation engines into clinical ones.
At the same time, the economics are shifting underneath them.
The return on coding optimization is shrinking.
The cost of poor outcomes is rising.
Avoidable admissions.
Chronic disease mismanagement.
Member churn tied to experience.
These aren’t side issues anymore.
They are margin drivers.
This is the part most organizations are underestimating.
Coding is no longer the strategy.
It’s the baseline.
Everyone is expected to get it right.
No one is going to win because of it.
The winners will be the plans that move first.
The ones that shift from retrospective capture
to proactive intervention.
The ones that stop asking, “Did we document it?”
and start asking, “Did we change it?”
Most payer organizations won’t make this shift quickly.
Not because they don’t understand it.
But because their entire operating model is built for something else.
And that’s where the opportunity sits.
The coding game isn’t evolving.
It’s ending.
The only question is how long it takes before your organization realizes it.
Why Healthcare Providers Are Spending Billions Just to Get Paid
Providers are spending over $25 billion a year just to get paid, not because claims are wrong, but because the system slows down valid ones. Most denied claims are eventually approved, exposing a costly cycle of rework, delays, and unnecessary administrative burden.
Getting paid in healthcare should be simple.
It isn’t.
Providers are now spending over $25 billion a year just working through claims. Not because the claims are wrong, but because the process is.
About 15% of claims get denied upfront. That sounds reasonable until you realize most of them are eventually approved and paid anyway.
That means the system is not catching bad claims. It is slowing down good ones.
Every denial triggers the same loop. Review. Resubmit. Wait. Repeat. Weeks turn into months. Multiply that across thousands of claims and the cost explodes.
This is not a technology issue. It is a workflow problem built into the system itself.
Then there is prior authorization. Providers ask for approval before care. They get it. Then the claim can still be denied later.
So now they ask for permission, receive permission, and still have to fight to get paid.
That is not control. That is duplication.
The impact is immediate. Hospitals are operating with tighter margins than they have in years. Cash is delayed. Staff is tied up in administrative work. Investment in care gets pushed out.
At the same time, these inefficiencies drive up costs across the system, contributing to higher premiums.
Nothing about this is accidental. The system is doing exactly what it was built to do.
The problem is what it was built to do no longer makes sense.
Most denied claims end up getting paid. Billions are spent proving what was already true.
Until payer rules are standardized, unnecessary approvals are reduced, and claims are validated before submission, this does not change.
Providers will keep funding a process that works against them.