A medical coding audit checklist is a fixed list of checks a billing team runs on a sample of coded encounters to confirm the codes match the documentation, satisfy payer rules, and support clean claims. Run it monthly or quarterly, score the same fields every time, and feed every recurring error back into training. Most coding audits find the same handful of failure modes, so a checklist turns a vague worry about accuracy into a short, repeatable routine.
This guide gives you the checklist itself: what to prepare, what to check on every sampled chart, how to score results, and how to close the loop with coders and payers.
At a glance
| Question | Practical answer |
|---|---|
| How often? | Monthly for high-risk specialties, quarterly minimum for everyone else. |
| How many charts? | 5 to 10 per coder per cycle, plus every denial tied to coding. |
| Who audits? | Someone who did not code the chart: a lead coder, auditor, or outside reviewer. |
| What gets checked? | Documentation match, code accuracy, modifiers, payer-specific rules, and charge capture. |
| What is the output? | An accuracy rate, an error list by cause, and one corrective action per cause. |
Before you open a single chart
Audit preparation determines whether the results mean anything. Get these five things in place first.
- Define the sample. Random charts give you an accuracy rate; targeted charts (high-denial CPTs, new coders, new payers) give you fixes. Use both: a random core sample plus a targeted slice.
- Freeze the rules. Note which ICD-10-CM, CPT, and HCPCS code sets, payer bulletins, and National Correct Coding Initiative edits were in effect on the date of service. Auditing old claims against current rules produces false errors.
- Pull complete documentation. The audit needs the full encounter note, orders, operative or procedure reports, pathology, and the claim itself with all codes and modifiers as submitted.
- Agree the scorecard. Same fields for every chart: encounter, coder, audit date, codes reviewed, error type, error cause, severity, and the corrected codes.
- Set the auditor. The person who coded the chart cannot audit it. Independence is what makes the number credible.
The chart-level checklist
Run every sampled encounter through these checks in order. Each check is a yes or no, with a note when the answer is no.
1. Documentation match
- Every diagnosis code is supported by a statement in the note, not by a history list or an assumption.
- Every procedure code is supported by documentation of the work actually performed, including laterality and approach.
- Codes reflecting conditions ruled out are handled with the correct outpatient or inpatient rules for uncertain diagnoses.
2. Code specificity and completeness
- The diagnosis is coded to the highest documented specificity, not an unspecified code when the note specifies.
- All reportable diagnoses for the encounter are captured, including chronic conditions that affect risk and medical necessity.
- Required laterality, encounter type (initial, subsequent, sequela), and combination codes are used where they apply.
3. Procedure and modifier accuracy
- CPT and HCPCS levels match the documented procedure, and units billed match the record.
- Modifiers (25, 59 or X{EPSU} subsets, LT/RT, 50, and payer-specific ones) are supported by documentation, not used to force an edit through.
- Bundling was checked against NCCI edits and payer policies before submission.
4. Medical necessity and linkage
- Diagnosis codes on the claim justify the procedure under the payer’s coverage policy.
- Primary diagnosis sequencing reflects the main reason for the encounter.
5. Charge capture and demographic match
- Every documented billable service appears on the claim, and no charge appears without documentation.
- Patient demographics, insurance, provider NPI, and place-of-service codes on the claim match the record.
Rule: an error is a mismatch between the note and the claim, not a difference of opinion about a defensible code choice. Record both: the hard error and the judgment call, scored separately.
Score the audit the same way every time
Two numbers do most of the work. The code accuracy rate is correct codes divided by total codes audited. The chart accuracy rate is charts with no errors divided by total charts. Most organizations treat 95 percent code accuracy as the working floor; set your own threshold in writing and hold it consistently.
| Metric | How to compute | What it tells you |
|---|---|---|
| Code accuracy rate | Correct codes / total codes audited | Overall coding quality |
| Chart accuracy rate | Error-free charts / charts audited | Risk of a fully incorrect claim reaching the payer |
| Error rate by cause | Errors per cause / total errors | Where training and process fixes should go |
| Denial overlap | Coding-attributable denials / total denials | Whether the audit found the same problems payers found |
Classify every error by type and cause: missing code, wrong code, unspecified code, modifier misuse, sequencing, bundling, or charge capture. Then classify the cause: knowledge gap, documentation gap, template problem, or workflow shortcut. The cause drives the fix; the type alone does not.
Close the loop
- Correct the claim for every error found on open claims, within the payer’s timely filing window.
- Give feedback within the cycle. Each coder gets their own results, one on one, with the chart examples attached.
- Fix the system causes. A template that omits laterality or an EHR default that pulls an old diagnosis will produce the same error in every coder’s work. Training cannot fix what configuration caused.
- Retest the same error types in the next cycle. A fix that does not show up in the next scorecard did not happen.
Coding accuracy does not stand alone; it depends on how well the underlying work is documented and translated. For a closer look at how documentation choices become code choices, see our guide to medical coding examples for better clarity. And because audit findings should push teams toward better tooling and workflow, it helps to understand the coding technologies that improve accuracy before you buy anything. For worked code sets across common encounter types, our billing and coding examples for professionals pair well with this checklist.
Common audit findings and what they mean
| Finding | Usual cause | Fix |
|---|---|---|
| Unspecified diagnosis codes on mature charts | Copy-forward notes lacking detail | Provider documentation training plus template prompts |
| Modifier 25 on nearly every E/M with a procedure | Workflow shortcut to avoid denials | Re-educate on significant, separately identifiable service |
| Charges missing for documented services | Charge capture gaps between note and claim | Reconcile charge sheets against closed encounters |
| Bundled pairs billed repeatedly | Edits not checked pre-submission | Turn on NCCI edit scrubbing before the claim drops |
| Laterality errors | Template does not force the field | Fix the template, then audit the fix |
What an audit will not fix
An internal coding audit checks whether codes match documentation. It will not fix under-documented encounters, providers who dictate after the fact, or payers that deny against their own published rules. Track those separately. Where documentation quality is the real constraint, address it at the source with provider education and template design rather than through the coders.
Frequently asked questions
How many charts should a medical coding audit sample?
A common working rule is 5 to 10 charts per coder per audit cycle, weighted toward high-risk procedure types, plus every claim denied for a coding reason. Small teams should audit a fixed percentage instead, such as 3 to 5 percent of encounters.
How often should billing teams run coding audits?
Monthly for high-risk specialties, new coders, or after a major payer or system change, and at least quarterly otherwise. The cadence matters less than running the same checklist every time.
What is a good medical coding accuracy rate?
Many organizations treat 95 percent code accuracy as the working floor. What matters more is trend: the rate should be stable or improving cycle over cycle, with the same error causes shrinking.
Who should perform the internal coding audit?
Someone who did not code the sampled charts: a lead coder, a compliance auditor, or an external reviewer. Self-auditing your own work defeats the purpose.
What is the difference between a prospective and retrospective coding audit?
A prospective audit reviews codes before the claim is submitted; a retrospective audit reviews claims after submission. Most internal programs are retrospective, with prospective checks reserved for new coders and high-dollar procedures.
Do audit findings need to be reported to compliance?
If the audit is part of a formal compliance program, findings, corrective actions, and retest results should be documented and retained. Even informal audits should keep written records of errors, causes, and fixes.
Start with one cycle
Pick 20 charts, run this checklist, and score two numbers: code accuracy and chart accuracy. List every error with its cause, make one fix per cause, and retest next cycle. An audit that repeats with the same scorecard becomes the cheapest quality control a billing team can run.
Need help building or running a coding audit program for your specialty? Talk to the VLMS Healthcare team about medical coding and billing services built around measurable accuracy.
Medical coding audit FAQ
How many charts should a coding audit sample?
Most teams audit 20 to 30 charts per cycle per coder, or about 5 percent of encounters. Small samples still reveal the top error patterns.
How often should we run a coding audit?
Monthly for new coders and new specialties, quarterly for stable teams. The cadence matters less than scoring the same fields every time.
What is a good coding accuracy rate?
Many organizations target 95 percent or higher overall code accuracy. Trends matter more than a single score, so track it audit over audit.
What happens after we find errors?
Log each error with its cause, fix one process per cause, retrain where needed, and retest the same checks next cycle. An audit without a fix loop is just a scorecard.