Case Study 2 — The Wrong Year: A Composite

Constructed. The practice, the payers, and the figures are not real. The failure — a contract loaded against the wrong year's fee schedule, underpaying every affected line by a small amount for two years — is ordinary, and the outcome is honest rather than triumphant.

Background

Section 28.8 was the promise six earlier chapters made, and it opened with the reason the question is hard:

An underpayment does not deny. It does not reject. It does not appear on any exception report. It arrives as a payment.

This is a practice that went looking, using exactly the method §28.8 prescribes, and found three different things — only one of which was the payer's fault.

The composite

Constructed.

A nine-provider specialty practice. Competent billing, autoposting in place, a manager who reads the reports.

It had never checked a payment against a contract. Not out of negligence — because doing so requires an expected allowed amount per line per payer, and the practice did not have its contracts in any form a computer could use. They were PDFs in a shared folder, which is where most contracts live.

(Constructed.) A new manager, arriving from a larger organization where this was routine, proposed the §28.8 exercise: top twenty codes by volume, top three payers by revenue. Sixty combinations.

It took most of a week, and the week was mostly spent on step 1 — reading three contracts carefully enough to state, for each of twenty codes, what the practice was supposed to be paid.

Finding one: the practice's own error

The first pass produced variances on a large fraction of the sixty combinations, which was discouraging until somebody looked at them.

(Constructed.) Most were the practice's own contract loading.

A multiplier entered against the wrong base schedule. A carve-out for a code family that had been negotiated and never recorded. And a lesser-of provision — Chapter 23 §23.7's rule that a payer pays the lesser of billed and allowed — that the expected-amount calculation had simply not implemented, producing predicted amounts above what any correctly written contract would pay.

§28.8's step 5 predicted this exactly: "the contract is loaded wrong" is the most common finding on a first pass.

It is unglamorous and it was not wasted. Until the expected amounts were right, nothing else could be detected, and the week that produced no recovery produced the instrument that found the rest.

Finding two: the claims

(Constructed.)

A smaller group of variances turned out to be the practice's claims rather than its contracts.

A place of service code — Chapter 25 §25.8, and Chapter 23's Case Study 1 is the same finding at a different practice. Units on a drug code that had been entered per administration rather than per descriptor dosage, Chapter 20 §20.3. And a modifier omitted on a code family where the contract paid differently with it.

These paid. They paid at the correct rate for what the claim said, which was not what happened.

An underpayment that is your own claim's fault looks identical to an underpayment that is the payer's, and the only thing that distinguishes them is somebody reading the claim.

Finding three: the wrong year

And then the one everybody had been hoping for, at the payer nobody suspected.

(Constructed.) The second-largest payer had loaded the practice's contract against a fee schedule from the wrong year.

The multiplier was right. The base schedule was one year stale.

The effect was small per line — a percentage point or two, varying by code because the underlying schedule's relative values had shifted unevenly, which is precisely why it had never been noticeable. Some codes paid slightly low. A few paid slightly high, because a stale schedule is not uniformly lower.

That last detail is why nobody had found it by intuition. An error that makes everything a little low eventually gets noticed by somebody with a good memory. An error that makes most things a little low and a few things a little high looks like the ordinary noise of a fee schedule.

The practice's finding was specific enough to act on: here are eleven codes, here is what your contract says, here is what you paid, here is the variance per line and in total, and here is the schedule year we believe you loaded.

What happened next

(Constructed.)

The payer confirmed it. Not immediately and not without escalation, but the finding was specific and verifiable, and the payer's own configuration record showed the year.

The rate was corrected prospectively. That part was straightforward.

And the recovery was bounded — not by the length of the error, but by the contract's reconsideration window.

   THE ERROR HAD BEEN IN EFFECT FOR ......  about two years
   THE CONTRACT'S RECONSIDERATION WINDOW
     PERMITTED REVIEW OF CLAIMS FROM .....  a materially
                                             shorter period
                                             ─────────────
   RECOVERED ............................. the claims inside
                                             the window
   NOT RECOVERED ......................... everything before it

The practice recovered a real amount and left more than it recovered.

§28.8 said the recoverable period is bounded by the contract's reconsideration window rather than by when you noticed. This is what that sentence means when it happens to you.

What it shows

First, the method worked and it did not feel like it was working. Most of a week on step 1, a first pass full of the practice's own errors, and a finding at the payer nobody suspected. Anyone evaluating this project at the halfway point would have concluded it was a waste, and the halfway point is where most such projects are abandoned.

Second, the practice's own errors outnumbered the payer's, and that is the normal result. It is worth saying plainly because the expectation going in is always the opposite. A first underpayment review is mostly an audit of yourself, and the practices that respond badly to that finding do not get to the third one.

Third, an error that is not uniform is nearly undetectable by experience. A few codes paying high concealed the ones paying low. Nobody's memory for what a code usually pays is good enough to defeat that, and the only instrument that works is a computed expectation compared line by line.

Fourth, the recovery window is the argument for doing this on a schedule. The error existed for two years; the money was available for less than that. Every month a review is deferred, a month's worth of findings ages out of recoverability — which makes this one of the few revenue cycle activities with a genuine, quantifiable cost of delay.

And fifth, the finding was actionable because it was specific. "We think you're underpaying us" produces nothing. Eleven codes, the contract language, the paid amounts, the variance, and a hypothesis about the schedule year produced a correction. Chapter 30's appeal discipline is the same discipline — an assertion with the evidence attached, addressed to somebody who can act on it.

The lesson

You cannot detect an underpayment by reading remittances. You can only detect it by computing what the remittance should have said.

Four carry-forwards:

Get your contracts into a computable form, one payer at a time. The multiplier, the base schedule, the year of that schedule, the carve-outs, the lesser-of provision. It is the whole difficulty and it is a one-time cost per contract, after which every future review is cheap.

Expect your first pass to be about yourself. Contract loading, then claims, then the payer. Budget for that emotionally and organizationally, because a project that promises recovery and delivers self-criticism gets cancelled by people who were not warned.

Ask what year. (Constructed, and the most transferable sentence in this composite.) When a payer's rates look subtly wrong across a whole code family, "which fee schedule year did you load?" is a question with a checkable answer, and it is not a question most billers know to ask.

And run it on a schedule, because the window closes. Annually at minimum. The cost of delay is not theoretical and it is not the same as the cost of the error — the error can be fixed prospectively at any time; the money can only be recovered inside a window that is already running.

Discussion questions

1. The first pass was mostly the practice's own errors. Was the week wasted? Say what it produced and what could not have happened without it.

2. Some codes paid slightly high. Why did that make the error harder to find than a uniform underpayment, and what does it say about relying on experienced staff to notice?

3. The recovery was bounded by the reconsideration window rather than by the error's duration. Compute the cost of a one-year delay in starting this project, in general terms. What does that imply about priority?

4. "Which fee schedule year did you load?" is a specific, checkable question. Write two more questions of that kind that a biller could ask a payer about a rate discrepancy.

5. Compare this with Chapter 23's Case Study 1, where a place of service code was never updated after a conversion. Both are silent underpayments. Which is easier to find, and why?

6. This practice had nine providers and its contracts lived as PDFs in a shared folder — which is typical. What is the smallest realistic version of step 1 that a practice this size could actually sustain?