Is your documentation actually supporting the codes you bill? Or is it just describing the visit in general terms? The gap between the two is bigger than most practices assume. A 2010 OIG review found that Medicare improperly paid $6.7 billion for E/M services in a single year. That’s 21 percent of total E/M payments. In that same review, 42 percent of claims were miscoded, and 19 percent were missing the documentation needed to support the code billed.
Athenahealth clinical documentation billing integration is about closing that exact gap. When an encounter template doesn’t map cleanly to the codes it’s meant to support, providers run into two problems. They either undercode out of caution, or overcode by accident. Both carry real financial and compliance risk. The fix isn’t more documentation. It’s better-aligned documentation, built directly into the templates providers already use every day.
This guide covers how to map EHR templates to billing codes accurately. It also covers how to shrink the lag between documentation and billing. And it explains how encounter macros inside Athenahealth can either help or quietly hurt coding accuracy, depending on how they’re built.
Why Documentation and Billing Drift Apart
Clinical documentation and billing codes are supposed to tell the same story. But they’re often written by different people, and reviewed at different times.
The Undercoding Problem
Undercoding happens when a provider documents a visit accurately from a clinical standpoint. But they don’t capture the specific details, like comorbidities or decision-making complexity, that would support a higher-level code. This isn’t usually intentional. It’s often a provider defaulting to a familiar, low-effort template. That template doesn’t prompt for the details a higher code actually requires. Clinical documentation improvement programs have been shown to reduce this kind of leakage substantially. Some organizations report claim denial reductions of 25 to 30 percent once documentation and coding practices are aligned.
Why Generic Templates Make It Worse
A generic encounter template gets built for speed, not for a specific specialty or visit type. It tends to capture the minimum needed to describe a visit. It doesn’t capture the specific elements a coder needs to justify a particular code level. This forces coders into one of two choices. They can query the provider after the fact, which slows the whole billing cycle down. Or they can default to a conservative code that doesn’t reflect the visit’s actual complexity.
Mapping EHR Templates to Billing Codes
The core fix is structural. Build templates so that documenting the visit naturally captures what the corresponding code requires. Don’t treat documentation and coding as two separate steps.
Starting With the Code, Not the Note
Effective template design works backward from the billing code. It identifies exactly which elements, like history, exam findings, or medical decision-making factors, need to appear in the note. These elements support that specific code. Templates built this way naturally guide a provider toward complete documentation. The provider doesn’t need to remember every requirement unprompted.
Building Specialty-Specific Templates
A single generic template rarely serves every specialty well. The documentation elements that matter for a cardiology visit look very different from those for a dermatology visit. Specialty-specific templates inside Athenahealth reduce this mismatch directly. A well-built template typically includes:
- Prompts tied to the specific E/M level being targeted
- Fields for relevant comorbidities and risk factors specific to the specialty
- Built-in space for medical decision-making detail, not just findings
- Structured fields rather than free text wherever coding accuracy depends on specificity
Reducing Documentation-to-Billing Lag
The longer the gap between an encounter and when it actually gets coded and billed, the more likely errors are to slip through uncorrected.
Why Lag Creates Errors
When coding happens days or weeks after a visit, a coder works from an incomplete note. They have no easy way to ask the provider what they meant, since the details of the encounter have already faded from memory. This turns a quick clarification into either a formal query process or a guess. Neither outcome is ideal for coding accuracy.
Closing the Gap With Point-of-Care Coding
Build code suggestions directly into the documentation workflow. A provider then sees a suggested code level while still writing the note. This closes the gap substantially. It doesn’t remove the coder’s role entirely. But it does mean the note and the code get built together. They don’t get reverse-engineered from an incomplete note days later.
Configuring Athenahealth Encounter Macros
Encounter macros can speed up documentation dramatically. But poorly configured macros are one of the most common causes of the undercoding and overcoding problems described above.
The Risk of Copy-Forward Macros
A macro that copies forward the same exam findings or history from a previous visit saves time. But it can also carry forward details that no longer apply. Or it can fail to reflect what actually changed at this specific visit. This creates a documentation record that doesn’t match the actual encounter. That’s a real compliance risk if it’s ever reviewed during an audit.
Building Macros Around Variability, Not Just Speed
The most effective macros are built to prompt for what’s likely to change at each visit. They don’t just default everything to the prior note. A macro that auto-populates stable information, like a patient’s known allergies, still requires active input on the elements that vary, like today’s decision-making. This strikes a better balance between speed and accuracy.
Documentation Elements vs Billing Requirements
The table below shows how specific documentation gaps map to specific billing consequences. This is often the clearest way to explain the connection to a clinical team.
| Documentation Gap | Billing Consequence | Fix |
| Missing comorbidity detail | Lower-level E/M code than the visit supports | Template prompt for relevant comorbidities |
| Vague decision-making language | Coder defaults to a conservative code | Structured MDM field in the template |
| Copy-forward findings with no update | Documentation doesn’t match actual encounter | Macro requires active confirmation, not silent carryover |
| Delayed coding after the visit | Errors go uncorrected due to faded memory | Point-of-care code suggestions during documentation |
Improving Coding Compliance Through Documentation
Better-aligned documentation doesn’t just improve revenue capture. It’s also the strongest defense a practice has during a payer or compliance audit.
A well-documented encounter, built from a template that maps clearly to the code billed, tells a consistent story. That story holds up under review. This matters, because both undercoding and overcoding carry compliance exposure, not just financial risk. A documentation trail that clearly supports the code billed protects the practice either way.
Conclusion
Athenahealth clinical documentation billing integration comes down to one thing. Make sure the note and the code get built from the same information, at the same time. Don’t treat them as two disconnected steps handled by different people, days apart. A few things move the needle here. Templates designed around what a code actually requires. Macros that prompt for what’s changed, rather than silently copying forward. A shorter gap between documentation and coding. All three point toward the same outcome: fewer errors, less rework, and a documentation record that holds up under scrutiny.
Documentation quality connects directly to both revenue and compliance risk. This is one of the few areas where a relatively small structural change, fixing how templates are built, can meaningfully move the numbers on both fronts at once.
FAQs
What’s the difference between undercoding and overcoding?
Undercoding happens when documentation doesn’t capture enough detail to support the code billed. This results in a lower, less accurate reimbursement. Overcoding happens when a code is billed at a higher level than the documentation actually supports. This carries its own compliance risk.
Can encounter macros actually hurt coding accuracy?
Yes, if they’re built purely for speed. A macro that copies forward the same findings from a previous visit, without requiring an update, can create a documentation record that doesn’t match what actually happened at the current encounter.
How does documentation lag affect coding accuracy?
The longer the gap between a visit and when it’s coded, the harder it becomes for a coder to clarify an unclear note. By that point, the provider’s memory of the specific encounter has usually faded.
Do specialty-specific templates really make a measurable difference?
Yes. A generic template tends to capture only the minimum needed to describe a visit. A specialty-specific template prompts for the exact details a coder needs to support a specific code level for that specialty.
How much can better documentation actually reduce denials?
Organizations that align documentation and coding practices through a structured program have reported denial reductions in the range of 25 to 30 percent. This mostly comes from closing the gap between what was documented and what the code required.
