Last updated: 2026-09-17
A coder hired into eClinicalWorks inherits a job that begins after somebody else stops typing, so this page opens with what the work is on that platform rather than in general. Encounters come next, because the queue is a list of visits in different states rather than a pile of paper. The provider's own selection during documentation follows, since starting from an answer someone already entered is a different task than starting from nothing. Why two practices running identical software give a coder different work comes after that, and the answer sits in template build and closing rules each office wrote for itself. An unclosed visit gets its own section, along with who's allowed to close one and what the delay costs. Then comes the review order to follow before a claim leaves. Coding and billing get pulled apart plainly, because they're two jobs sharing one database. The code sets an ambulatory office runs on come next. A provider query follows, including how to ask without editing anybody's note. What a coder can't do, and what your practice still owns, sits after that. Hiring criteria come near the end, along with the rate and the terms that Honest Taskers publishes. Where these eClinicalWorks facts come from closes the page.
A medical coder in eClinicalWorks reads finished visit documentation, confirms that the diagnosis and procedure codes hanging off that visit are the ones the note supports, resolves what doesn't line up, and clears the charge so a claim can be built.
Order matters here more than it sounds. eClinicalWorks keeps the chart and the practice management side in one product, so a code a physician picked inside the note is the same code sitting on the claim a few steps later. Nobody retypes it in between. A coder who treats the platform like a blank worksheet spends the day re-entering what's already on the screen and misses the one thing worth catching.
Reading takes most of the hours. The note comes first, the attached codes second, and whatever sits in the gap between them is the finding. On a busy internal medicine schedule that gap shows up a handful of times a day, on the visits where something extra happened and the documentation didn't grow to match.
Who the coder reports to varies. Some offices run coding under the billing manager, others under the practice administrator, and a few park it with the lead clinician. Settle that before the first disagreement about a level.
A coder's day in eClinicalWorks runs on a worklist of encounters, and every one of them sits in a state that decides whether a coder can touch it yet.
Three states account for nearly every item on that list.
Only the first of those three is coding work. The other two are chase work, and pretending otherwise is how a coder ends up reporting a full queue while revenue sits still. Separate the two lists on day one.
Age is the sorting rule that beats volume. A visit from eleven days ago with no signature is worth more attention than twenty clean ones from this morning, because the clean ones will still be clean tomorrow. Most offices set a documentation deadline in their own policy, and a coder's job here is making the breaches visible by name, by provider and by date rather than as a count.
When the provider picks the code during documentation, a coder's job shifts from assignment to verification, and verification carries its own failure mode. Starting from an answer already on the screen pulls a reviewer toward agreeing with it. That pull is the thing to plan against.
The defense is a reading order, held to stubbornly. Read the note with the codes covered, decide what the visit was, then look at what got selected. Coders who reverse that order tend to find the documentation that supports the code and skip the documentation that contradicts it.
Template defaults deserve their own suspicion. A progress note template built around one physician's habits carries that physician's favorite diagnosis into every patient who walks through it, and after a few hundred visits the pattern looks like clinical consistency rather than a default nobody switched off. Under-coding hides just as well as over-coding does, and it's the one nobody reports.
Changing a selection isn't a quiet edit either. A code a clinician chose reflects a clinical judgment, so the correction runs through a question rather than a keystroke. That single constraint shapes more of the day than any screen in the software.
Two practices on eClinicalWorks give a coder different work because the parts that decide the work are local build decisions, not platform behavior. The software ships; the office configures.
Six of those decisions change the job description outright.
So a candidate with three solid years in eClinicalWorks at a cardiology group still needs a map of your build. Give them one in writing during onboarding, and budget a week where output is lower than it will be in month two. The alternative is discovering the gap through a denial. For the tooling that sits around the platform, our rundown of medical coder tools and software covers the reference layer.
An unclosed encounter costs the practice the entire claim until somebody closes it, and the signature that closes it belongs to the clinician who saw the patient. That isn't something a coder can supply. Neither can a biller, an administrator, or the person who built the template.
Two clocks run at once while a visit sits open. Payers set a filing deadline measured from the date of service, and the practice's own cash cycle stretches by exactly the number of days the note waits. Neither clock pauses for a physician on vacation.
What a coder owns here is visibility, not authority. A weekly list that names the provider, the patient, the date of service and the reason the visit is stuck does more than a dashboard number, because a physician answers a specific ask and ignores a total. Scribes and assistants can draft documentation where the practice permits it, and the attestation still belongs to the clinician.
Worth saying plainly to anyone hiring for this seat: unsigned visits are a physician behavior problem wearing a software costume. Remote coders make them visible and cheap to fix. Somebody inside the practice still has to care. The broader remote-support picture sits in our guide to how a virtual assistant works in eClinicalWorks.
A coder reviews a note by reading the clinical documentation first, the attached codes second, and then checking the small set of fields a payer reads before anything else on the claim.
Diagnosis specificity is the usual first stop. Laterality, acute versus chronic, initial versus subsequent, and the underlying condition behind a symptom all sit in the note or they don't, and an unspecified code chosen out of habit when the documentation supports a specific one is the quietest revenue leak in an ambulatory office.
Linkage comes next, meaning each procedure line pointing at the diagnosis that justifies it rather than at whatever sat first in the list. Then modifiers, which carry more denial risk per character than anything else on the claim. Units, place of service, date of service and the rendering clinician follow, which matters most when a supervising arrangement is involved.
None of that is exotic. It's a sequence, done the same way on visit forty as on visit four, and the sequence is what a practice is buying when it hires a coder. Speed arrives later, from repetition inside one build, and a coder who's fast in week one is skipping the note.
No, coding and billing are two jobs, and eClinicalWorks makes them look like one because both sit on the same database with no visible seam between them. A charge that a coder cleared appears on the billing side without an export, an interface or a handoff email.
The line sits at the question each role answers. A coder answers what the visit was, in code, and whether the record supports that answer. Whether the claim reached the payer, what came back and what to do about it belongs to the biller.
Denials sort themselves along the same line once you watch a few. A medical necessity denial, a bundling edit or a modifier rejection belongs to coding and needs the note reopened. Subscriber identification mismatches, missing authorization numbers and timely filing rejections belong to billing and never touch the chart.
Practices that hire one person for both jobs should say so out loud in the job posting instead of letting it happen by drift. The combined seat is real and common in a four-provider office. It's also a different candidate, and the role definition in what is a medical coder is the cleaner starting point for that conversation.
A coder in an ambulatory practice works four code sets, and eClinicalWorks holds all four against the same visit record.
Each set answers a different question on the claim.
Office visit levels changed how they're chosen, which still trips coders trained on the older rules. Level selection for an office or outpatient visit rests on medical decision making or on total time spent on the date of the encounter, so a note thick with history and exam detail doesn't move a level by itself. The Centers for Medicare and Medicaid Services publishes the current Medicare coding and billing rules that govern this (Source: Centers for Medicare and Medicaid Services, 2025).
Specialty decides the mix. A dermatology practice lives in procedure codes and modifiers; a behavioral health practice lives in time-based codes and a short diagnosis list. Ask which one you are before writing the job ad.
A coder queries a provider by asking a question that states what the record shows and stops there, sent through whatever internal task or message route the practice has turned on inside eClinicalWorks. The coder never types into the clinical note.
A compliant query doesn't steer the answer, which in practice means it doesn't name the code the coder wants. "The note documents a wound repair and lists a length in the assessment, and the procedure section doesn't give a length" is a query. "Can you add 2.5 cm so this bills at the higher code" is not, and it survives an audit badly. The American Health Information Management Association publishes guidance on compliant query practice that most hospital and office coding policies are built from.
The answer belongs in an addendum the clinician writes, dated when it was written rather than backdated to the visit. An addendum that stands on its own reads fine three years later in front of a payer auditor. One that contradicts the original note reads worse than the gap it was meant to fix.
Query volume is worth tracking by provider rather than in total, since a single template that keeps dropping a required element generates the same question forty times. Fix the template and the queries stop. That instinct, along with the rest of the skill set, sits in our breakdown of medical coder skills.
A coder can't sign a note, can't change what a clinician wrote, and can't decide that a service was medically necessary when the record doesn't say it was. Those three limits hold no matter how good the coder is or how long the claim has been waiting.
Five things stay with the practice permanently. Granting and revoking system access, building and maintaining templates, setting the closing policy and enforcing it, owning the compliance plan and the audit response, and giving final sign-off where the practice requires a clinician to approve a code change. A remote coder works inside those decisions and doesn't get to make them.
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, so a nurse reviewing your documentation is doing coding work under your policies and isn't practicing under a license for you. Published occupational descriptions draw the same boundary. The US Bureau of Labor Statistics describes the closest published occupation, medical records and health information technicians, in its "Occupational Outlook Handbook" (Source: Bureau of Labor Statistics, 2025), where the duties listed are organizing and coding health information rather than clinical judgment.
Access is granted by the client, one named account at a time, with the permissions the practice chooses. The conversation to have with your vendor is set out in our explainer on whether a virtual assistant can work in your EHR.
Look for a coder who describes a build rather than a button, because build knowledge is what transfers into your system and button memory doesn't. Ask what the templates looked like at their last practice and what they'd change about them. Candidates who've done the work have an opinion within one sentence.
Credentials give you a floor, not a ranking. The AAPC issues the Certified Professional Coder credential widely held in office-based coding, and specialty credentials exist above it. Pair the credential with a short practical test on your own redacted notes, since that catches what a certificate can't.
Coding companies and staffing firms both place this role, and the terms differ more than the job descriptions do. Honest Taskers can prioritize candidates who have worked in eClinicalWorks, and candidates report experience with platforms such as Epic, athenahealth, 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.
On terms, Honest Taskers recruits in the Philippines, Latin America, India and Pakistan, and professionals work the client's US time zone and approved schedule. Rates run $10.00 to $12.65 an hour depending on the role, candidate background, schedule and location. New clients may receive a two-week working trial with their first selected professional, subject to current service terms, and replacement support is unlimited. Professionals are HIPAA-trained with quarterly HIPAA and data privacy training, a Business Associate Agreement is signed when a professional will access protected health information, and Honest Taskers describes its own security environment as SOC 2 audit ready. Reported retention runs 99.6% average monthly. The hiring sequence itself is laid out in our guide to how to hire a medical coder.
Honest Taskers rates, recruiting geography, trial terms, retention figure and compliance posture come from the company's own published rate card and service terms. Code set rules and office visit level selection come from the Centers for Medicare and Medicaid Services. Query practice guidance comes from the American Health Information Management Association, the coding credential from the AAPC, and the occupation description from the Bureau of Labor Statistics. Encounter states, template behavior, closing rules and denial routing above describe general ambulatory practice rather than one organization's protocol. No screen name, menu path, module name or version number for eClinicalWorks appears anywhere on this page, because naming one wrongly would send a coder looking for something that isn't there. Accuracy rates, denial rates, charts-per-day figures and turnaround times are absent for the same reason, since those move by specialty, build and payer mix.
Practices that have settled how the coding seat works and want to compare providers next have a separate question to answer, and it turns on structure rather than skill. A staffing arrangement gives you one named coder inside your own system on your schedule. Hiring a coding company instead gives you a team, a service level and a queue you don't manage. Volume, denial exposure 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.
Request candidates with experience in your specialty and software.
