Understanding medical billing: how a claim actually gets paid

A patient hands over an insurance card at the front desk, sees the doctor for fifteen minutes, and leaves. Three weeks later the practice gets paid, or doesn't. Everything that happens in between is medical billing, and most people picture it as one step: "send the bill." It's closer to a relay race with six or seven handoffs, and a dropped baton at any point means the money slows down or disappears.

Understanding that whole path is useful even if you're aiming for the coding chair, not the billing one. The two jobs share a pipeline, and half the code-book rules that feel arbitrary in a textbook make sense the moment you see what a payer does with the claim.

It starts before the patient sees the doctor

Billing's first decision happens at check-in, before anyone touches a code. The front desk copies the insurance card and verifies eligibility: is this coverage active today, is this plan primary, does the visit need a referral or prior authorization?

That last one causes more lost money than any coding mistake. If a service needed the payer's approval in advance and nobody got it, the claim comes back unpaid and usually can't be rescued after the fact. So a good front desk is really the first line of billing defense. Garbage collected here becomes a denial three weeks later.

Registration also captures the boring stuff that has to be perfect: legal name spelled the way the insurer has it, date of birth, member ID, group number. A transposed digit here doesn't cause a denial. It causes a rejection, which is a different and slightly better problem, and we'll get to why.

The coding handoff

Now the visit happens and the provider documents it. A coder reads that note and turns it into codes: CPT for what was done, ICD-10-CM for why, HCPCS Level II for the supplies and drugs that CPT doesn't cover. If you want the mechanics of those code sets, I've written separate walk-throughs of CPT codes and ICD-10-CM.

The biller takes those codes and attaches the money. Each CPT code maps to a charge on the practice's fee schedule, and the biller assembles them into a claim along with the diagnosis codes that justify them. This is the seam where billing and coding meet, and it's exactly why the two jobs get bundled in every training program even though they're different desks.

The pairing matters more than beginners expect. A procedure code has to be supported by a diagnosis code the payer accepts as a reason for it. Billing a diagnostic test with a diagnosis that doesn't justify it is how a clean-looking claim turns into a medical necessity denial.

Building the actual claim

There are two main claim formats, and which one you use depends on who's billing.

Physician offices and outpatient providers bill on the CMS-1500 (the electronic version is the 837P, P for professional). Hospitals and facilities bill on the UB-04, or the 837I for institutional. Same idea, different form, different fields. A coder who ends up in an outpatient clinic lives on the 1500 side and may never touch a UB-04.

Before that claim goes anywhere, it gets scrubbed. Claim scrubbing software runs the claim against thousands of edits: is this code valid for this date, does this procedure need a modifier, do these two codes bundle together, is the patient's sex compatible with the diagnosis? The goal is a clean claim, meaning one that goes through on the first try. Practices track their clean claim rate because every claim that bounces costs staff time to rework, and time is the one thing a billing department never has enough of.

The clearinghouse and the payer

Most practices don't send claims straight to insurers. They send a batch to a clearinghouse, which is a middleman that checks formatting, splits the batch by payer, and forwards each claim to the right place. The clearinghouse is where a lot of rejections surface: a missing field or a bad member ID gets kicked back here, before the payer ever sees it.

This is the rejection-versus-denial line I promised earlier. A rejection means the claim never entered the payer's system, usually a data problem. You fix it and resubmit, no appeal needed. A denial means the payer received the claim, processed it, and decided not to pay. That's a formal decision, and reversing it takes an appeal with evidence. Denials are where practices lose real money, and I went deep on the common ones in why insurance claims get denied.

Once a clean claim reaches the payer, it goes through adjudication. The payer checks the patient's eligibility again on their end, applies the terms of the plan, and compares the charge to the contracted allowed amount. Billed charge and allowed amount are almost never the same number, and the gap between them isn't a loss. It's a contractual adjustment the practice agreed to when it signed with that insurer, and it gets written off, not billed to the patient.

The money comes back, in pieces

When adjudication finishes, the payer sends back a remittance: the electronic 835, often called an ERA, plus an explanation of benefits to the patient. The remittance is a line-by-line verdict. It says what the payer allowed, what it's paying, what it adjusted off, and what it's leaving on the patient.

The biller posts those payments, matching each line back to the original claim. And this is where the patient re-enters the story, because most plans leave part of the bill with them. The deductible is what the patient pays before the plan kicks in. The copay is the flat fee for the visit. Coinsurance is the patient's percentage share after the deductible. Whatever the payer didn't cover for those reasons becomes patient responsibility, and the practice sends a statement.

Then comes the least glamorous and most valuable part of the job: accounts receivable follow-up. Not every claim comes back paid, and not every one comes back at all. Someone has to work the aging report, chase the claims that went quiet, appeal the denials worth appealing, and decide when a balance is never coming and should be written off. A practice's financial health lives in this queue more than anywhere else.

Why the coder should care

Here's the thing that took me too long to appreciate early on: by the time a biller sees a denial, the mistake is usually old, and it usually happened at the coding desk. Maybe an unspecified diagnosis that didn't support necessity, or a modifier that shouldn't have been there, or two codes billed separately that the payer bundles. A biller can appeal, but the coder could have prevented the whole thing.

That's why "clean claim rate" is a coding metric as much as a billing one. Coders who understand what a payer does with their work code to the documentation's full specificity, know their bundling edits, and query the provider instead of guessing. The billing pipeline is the reason those habits pay off.

It's also worth knowing where these jobs sit. In a small practice, one person often does the whole relay, coding in the morning and working denials in the afternoon. In hospitals and large groups they're separate departments with separate ladders. If the billing side is the part that interests you, the credential that matches it is the CPB rather than the CPC, and I compared them in CPC vs CPB.

Whichever chair you're headed for, the claim's path is the map that makes the rest of the field legible. Our study guide and exam simulator builds that context in on purpose: 700 exam-style questions with the reasoning behind every answer, including the compliance and payer-logic scenarios that separate a passing score from a guessing one.