Last updated: 2026-09-17
A coder hired into athenahealth walks into a queue of claims the software stopped on the way out, so this page starts with the coding work the platform leaves behind rather than the work it takes off your desk. Why a claim goes on hold instead of straight to the payer comes next, since the reason attached to it is where every review begins. Working one held claim through to submission follows, outcome by outcome. Then comes the part that separates this platform from one each office configures alone, which is what a centrally maintained payer rule set changes about who catches an error and when. Where a coder's authority stops and a provider's signature begins sits after that, with the corrections a coder makes alone and the ones that travel back. What a remote coder can't see about a hold gets its own section, because distance hides things a hallway doesn't. Coding and billing then get pulled apart, since a hold list mixes the two and only half of it is coding. Patterns that show up across a whole group come next, followed by what to do when one rule keeps firing on one provider week after week. Decisions that stay with the practice sit near the end, along with the limits worth writing into the job description. Who to hire, what to test them on, and what Honest Taskers charges come after that. Where these athenahealth coder facts come from closes the page.
A coder in athenahealth spends most of the day on claims the platform has already stopped, so the job reads as review and judgment rather than data entry. Codes reach the claim before the coder does. They arrive from what the provider selected during the visit, or from the charge somebody built off a fee slip, and the coder's first task is testing them against the record instead of inventing them.
Three jobs fill the week. Reading the reason a claim stopped comes first, then the note behind that claim, then a decision about which of the two is wrong. Nothing in that sequence is quick, and a coder who flies through it in week one is skipping the note.
Software can test a claim. It can't read a note. The payer rules behind athenahealth check what sits on the claim, which means a visit coded two levels below what the documentation supports clears every edge of the rule set and pays less than it should. Under-coding is the error no rule catches, and it's the one a practice never hears about from a payer.
Specialty decides the shape of the queue. A dermatology group throws off procedure lines and modifiers all day, while an internal medicine group throws off diagnosis specificity and visit levels. Settle which one your practice is before you write the responsibilities into a job description, because those two queues reward different reading habits.
A coder's claim goes on hold because it failed a payer rule athenahealth maintains for every practice on the platform, not one the office wrote for itself. The hold is a prediction. Somebody's rule says this claim, in this shape, comes back denied, so the platform stops it on the way out and attaches a reason to it.
Money is the argument for working holds ahead of anything else. A held claim costs one review. That same claim denied costs a review, a correction, a resubmission and the weeks in between, while the filing clock the payer set keeps running through all of it.
Five things put a claim on hold in an ambulatory practice more than anything else does.
Bundling edits behind the first of those come from the national correct coding initiative, and the Centers for Medicare and Medicaid Services publishes the current Medicare coding and billing rules that define them (Source: Centers for Medicare and Medicaid Services, 2025).
Reading the reason text is the whole skill. It names the rule, and the rule points at the field worth testing, which is why an experienced coder opens the note already knowing what to look for. Guessing works until it doesn't.
A coder works a held claim by reading the reason it stopped, opening the record for that date of service, and deciding whether the claim or the documentation is the thing that's wrong. Order matters. Read the reason first and the note second, because the reason narrows what you're testing, and a note read cold takes three times as long.
Four outcomes end a held claim, and two belong to the coder. Corrections come first, where the record supports a code other than the one submitted, and that correction gets made without asking anybody. A modifier goes on where the documentation shows the circumstance plainly. Everything the note can't carry travels back to the provider. The fourth outcome isn't coding, and it belongs to whoever owns registration and coverage.
Clearing the hold isn't the goal. A correct claim is. Coders measured on how many holds they cleared learn to make the fastest change that satisfies the rule, which is how a practice ends up with a queue that empties and a denial rate that never moves.
Keep the reasoning where the next person finds it rather than in somebody's head. One line saying what got checked and why the change was made turns a claim into something a second reader can audit two years later, and audits are the reason that habit exists at all.
A coder working under a centrally maintained payer rule set stops being the first reader of a bad claim and becomes the second. The vendor's rules catch the predictable errors. What's left on the coder's screen is the population of claims where a rule and a record disagree, and a disagreement needs a person.
Three consequences follow. Rule updates arrive without anybody at the practice asking for them, so a claim shape that cleared in March can hold in June. Nobody at the office switches off a rule they find annoying, which quietly kills a bad habit. And the same edits run for every practice on the platform, so a coder moving between athenahealth clients recognizes the reasons on day one.
What the rule set doesn't do is read the chart. No edit anywhere tests whether a note supports the visit level attached to it, whether a procedure described in two lines happened the way the code says, or whether a diagnosis carried forward from last year still fits the patient in front of the provider. Those are the questions that pay for a coder, and no vendor rule has ever answered one of them.
So the fix for a repeating hold sits outside the software entirely. Nobody at the practice edits the rule, which leaves documentation and coding behavior as the only two things a practice can change. The work sitting either side of that line is laid out in our guide to medical coder duties and responsibilities.
A coder's authority stops where a correction would change what the clinician said happened. Everything before that line is cleanup. Past it, the question stops being clerical and becomes documentation, which belongs to the person who signed the note.
Four kinds of correction get made without asking, because the record already carries the detail.
Everything else goes back. A service the note doesn't describe, a visit level the documentation won't hold, a question about whether the work was medically necessary, anything needing a clinical statement, all of it returns to the provider and waits for an addendum the clinician writes and dates. Coders don't type into a clinical note. Practices that let the boundary blur find out during an audit, which is the worst place to find out anything.
Both failure modes deserve naming. One coder adds what they assume the provider meant and calls it a correction. Another downgrades every held claim to whatever clears the rule, which looks careful and costs the practice money on visits the record supported. Write the policy down, including which corrections go through unasked and which always travel back, and the pressure to guess drops. The role itself is defined in our explainer on what is a medical coder.
A remote coder can't see anything that never reached the record. The hold reason is a machine sentence. It names a rule and a claim line, and it says nothing about the conversation at the front desk, the page that got scanned into the wrong chart, or what the provider meant to write before the next patient arrived.
Permissions decide the rest. A coder granted claim access and nothing else works half blind, because the answer to most holds sits in a document, a prior visit or a scanned report rather than on the claim itself. Read access to the chart and the document inbox separates a coder who resolves a hold from one who forwards it. That's the same access conversation any remote assistant needs before day one, and the client grants it account by account.
Distance also hides why a hold is old. A claim sitting eleven days can be waiting on a provider, waiting on a document, or waiting on nobody at all because it was never picked up, and those three look identical from another continent. Ask the coder to mark which of the three applies, every time, on every claim they touch.
One named person inside the practice, answering coding questions inside a working day, fixes more of this than any system setting will. Honest Taskers professionals are HIPAA-trained, work the client's US time zone and approved schedule, and a Business Associate Agreement gets signed when a professional will access protected health information. The permission conversation to have with your vendor sits in our explainer on whether a virtual assistant can work in your EHR.
No, coding and billing stay two jobs, and a hold list is the place they look like one. Half the reasons on that list have nothing to do with a code. They belong to registration, coverage and the patient account, and the coder's job on those is routing them fast rather than solving them.
The split gets obvious after a week of watching it. Bundling, specificity, modifiers, units and visit levels are coding holds, answered by reading the note. A subscriber number that doesn't match the plan, coverage that ended before the visit, a missing authorization number, a claim aimed at the wrong payer address, none of those improve by reopening a chart.
Prior authorization is the clearest example of the split. Nothing in the note fixes an authorization nobody obtained, and the American Medical Association publishes its own research on the burden prior authorization puts on physician practices (Source: American Medical Association, 2025).
Small practices hire one person for both seats, and that's a real arrangement rather than a mistake. Say so in the job posting instead of letting it happen by drift, because the combined seat draws a different candidate and produces a different day. The reference layer both seats lean on shows up in our rundown of medical coder tools and software.
Coding problems belonging to a template, a payer contract or one location show up only when somebody works every provider's holds side by side. One coder on a single schedule sees claims. A coder across the group sees patterns, and the pattern names where the fix lives.
Three shapes come up again and again. One provider holding on the same rule is a habit, and a habit gets answered with a ten-minute conversation. A whole location holding on registration or coverage reasons is a front-office problem. Every provider holding on the same edit points at the template, the charge setup, or a payer contract change nobody circulated.
Counts belong in that report, and they come from the practice's own queue rather than from somebody else's published average. Sort by rule, by provider, by location and by month. Numbers pulled from somebody else's practice describe somebody else's payer mix, and no figure on this page substitutes for the one your own data produces.
One caution about the report itself. A league table ranking providers by hold count reads as an accusation and gets the coder frozen out, which costs more than the holds ever did. Take the pattern to whoever owns the template, and let that person carry it to the clinician. The wider remote-support picture sits in our guide to how a virtual assistant works in athenahealth.
A coder should stop clearing that hold claim by claim and take the pattern to whoever owns the template or the training. Clearing it forty times is forty times the work and none of the cure.
The ask has to be specific enough to act on. Name the rule, name the provider, give the count over a stated period, and write the one sentence of documentation that would have kept every one of those claims moving. A missing laterality, a drug name without units, an injection site nobody recorded, each of those is a field, and a field is something a template can carry.
Fixes live in three places, and none is the coder's screen. A template changes so the field can't be skipped. Somebody holds a short conversation with the clinician. Or charge capture changes so the code stops reaching the claim in that shape.
Then check whether it worked. Pull the same rule a month later and see whether the count fell, because an ask nobody acted on looks exactly like an ask nobody made. A coder can't force a template change or a physician's habit, and pretending otherwise puts the blame in the wrong seat when the count holds steady. The judgment underneath all of it shows up in our breakdown of medical coder skills.
A coder works inside five decisions the practice never hands over, and the list is worth reading before the first disagreement. System access and permission levels belong to the practice, one named account at a time. So does the compliance plan, along with whoever answers when an audit letter arrives. Template changes sit with the person who owns the build. Appeals and write-offs are the practice's money rather than the coder's call, and the clinician's signature decides how the other four land.
The limits deserve a line in the job description. A coder can't sign a note, can't write documentation for somebody else, can't make a payer rule stop firing, and can't decide a service was medically necessary when the record doesn't say so. Honest Taskers staff do administrative and clinically adjacent work and never give clinical advice or make clinical decisions. The talent pool includes licensed nurses and physicians, which describes how the company recruits rather than what a placement does. Published occupational descriptions draw the same boundary, and the US Bureau of Labor Statistics sets out the closest one, medical records and health information technicians, in its "Occupational Outlook Handbook" (Source: Bureau of Labor Statistics, 2025).
Hire a coder who can read a payer rule, disagree with it, and put the disagreement in writing. Speed comes from repetition inside one build. Judgment doesn't, and judgment is what a queue of held claims asks for all day long.
Test for it rather than asking about it. Hand a candidate a redacted held claim with its reason attached and watch what they reach for first. The ones who've done this work ask for the note before saying anything about the code, and they'll tell you which claims they'd send back instead of fixing.
Credentials give you a floor rather than a ranking. The AAPC issues the Certified Professional Coder credential that's widely held in office-based coding, and specialty certification sits above it. Pair whatever certificate a candidate holds with that practical test, since a test catches what a credential can't.
Honest Taskers can prioritize candidates who have worked in athenahealth, and candidates report experience with platforms such as Epic, eClinicalWorks, AdvancedMD, NextGen and Tebra alongside it. More than 200 EHR systems are in use across US healthcare, and candidates bring experience with many additional platforms beyond those names. Availability depends on the role, the schedule and the specialty you need covered.
Terms decide whether any of this is worth doing, so here they are. Rates run $10.00 to $12.65 an hour, set by the role, the candidate's background, the schedule and their location. Recruiting happens in the Philippines, Latin America, India and Pakistan. Whoever you hire works your US time zone and the schedule you approve. New clients may receive a two-week working trial with their first selected professional, subject to current service terms, and replacement support carries no cap. Professionals are HIPAA-trained, with quarterly HIPAA and data privacy training behind them, and a Business Associate Agreement is signed when somebody will access protected health information. Honest Taskers describes its own security environment as SOC 2 audit ready and reports 99.6% average monthly retention, which matters in this seat because build knowledge walks out the door with the person holding it. The hiring sequence, from job description through trial, sits in our guide to how to hire a medical coder.
Honest Taskers rates, recruiting regions, trial terms, retention and compliance posture come from the company's own published service terms and rate card. Coding and billing rules, including the national correct coding edits behind many holds, come from the Centers for Medicare and Medicaid Services. Prior authorization burden comes from the American Medical Association, the coding credential from the AAPC, and the occupation description from the Bureau of Labor Statistics. Hold behavior, reason text, permission design and group-level patterns above describe how ambulatory coding runs in general rather than one organization's internal policy. No screen name, menu path, module name, version or price for athenahealth appears anywhere on this page, because a wrong one sends a coder hunting for something that isn't there. Rule counts, hold rates, denial rates, claims-per-day figures and turnaround times are absent too. Those move with specialty, payer mix and build, so a borrowed number would describe somebody else's practice instead of yours.
Practices that have settled how the coding seat works still carry a staffing question, and it turns on volume rather than skill. One named coder inside your own athenahealth build learns your providers and your payers, and that knowledge stays with the person. Coding companies sell a team, a service level and a queue somebody else manages, which suits a group whose hold volume swings week to week. Denial exposure, the number of providers billing, and how much of your build lives in one person's head all point at one answer or the other. The arrangements sit side by side in our ranking of best virtual medical coder companies.
Speak with Honest Taskers about building a remote healthcare support team.
