Last updated: 2026-09-21

Coding and billing share a job posting until the first account opens. What a coder does in Epic begins inside a health system's work queue, so the job description comes first. Pulling accounts from a coding queue follows right behind it, because a coder here takes charges in turn rather than one paper superbill at a time. Separating professional-fee coding from facility coding sits next, since the two answer different questions about one visit. Reading the signed note comes after that, because a code the record won't carry is a problem no biller repairs downstream. Defending a modifier follows, then routing a documentation question to the provider, since the honest answer to a thin note is a question and not a guess. What happens when a coding edit stops a charge comes next, because a held charge waits on whoever chose the code. Keeping the code set current across each build follows, then leaving an audit trail a reviewer can read a year later. Access is the question large organizations ask hardest. Where a remote coder falls short closes the practical side, and the sources behind these facts end the page.

What does a coder do in Epic?

A coder does the reading half of the revenue cycle in Epic, turning a provider's signed note into the diagnosis and procedure codes the documentation will stand behind. Billers take those codes and get the claim paid. Guess wrong as a biller and you've made a rework queue. The same guess from a coder makes a compliance problem, and the organization carries it for as long as the record stays open. Those are duties and responsibilities the two roles don't share.

Several pieces of work fill a coder's day inside a large health system.

• Reading the full encounter record, meaning history, exam, assessment and plan, rather than the diagnosis line alone.
• Assigning diagnosis codes to the conditions the record shows the provider documented and addressed at that visit.
• Assigning procedure codes to the work the record shows the provider performed and described.
• Adding a modifier where the record carries the fact that justifies it, and leaving it off where it doesn't.
• Sending a query when the record won't support any code cleanly, then holding the account for the answer.

Epic runs in large health systems, hospital-affiliated groups, big ambulatory organizations and the billing companies that serve them, so a coder here usually works inside a team and picks up accounts from a shared queue. Calling that person a general administrative assistant with a code book doesn't fit the work at all.

How does a coder pull work from a coding queue in Epic?

A coder pulls work from a coding queue in Epic by opening the queue assigned to their role, taking the next account in turn, coding it, and releasing it so the charge moves on. The queue replaces the stack of paper superbills a coder once worked one sheet at a time, and it lets a team split a day's volume without two people opening the same account.

Charges route between coder and biller through review flags, so an account rarely travels in one direction only.

• An account waiting for codes, ordered by the rule the organization set, such as date of service, specialty or payer.
• A review flag a coder raises to send an account back to a biller, or a biller raises to send one to a coder.
• A hold state for an account a coder can't finish until a provider answers an open question.
• A stamp of who opened the account and when, since a large organization tracks every handoff.

Working a queue means a coder rarely chooses the order of the day, and the account that jumps the line is usually the one a payer put a clock on.

How does a coder separate professional-fee coding from facility coding in Epic?

A coder separates professional-fee coding from facility coding in Epic by asking which side of the visit a code reports, because the two describe one encounter from two positions. Professional-fee coding, or pro-fee, covers the clinician's own service. Facility coding covers the site, meaning the room, the staff, the supplies and the time the building carried.

One visit can produce a professional charge and a facility charge that don't line up, and that surprises a coder who learned only one side.

• The pro-fee side asks what the clinician did and decided, and it rests on the note that clinician signed.
• The facility side asks what the hospital or site provided, and it rests on the resources the visit consumed.
• The same procedure can carry a modifier on the pro-fee side that has no meaning on the facility side.
• A coder credentialed for one side isn't automatically ready for the other, so the organization names which side the role owns.

Large systems often staff the two streams as different desks, so a coder reads the account header to learn which question they're answering before a single code goes down.

How does a coder read a signed note before assigning codes in Epic?

A coder reads a signed note before assigning codes in Epic by working the note from the top instead of jumping to the assessment, because the codes that survive review are the ones the whole record supports. The assessment names a condition. Whether the provider evaluated it that day comes out of the history and the exam.

Coders check four things in the record before a code goes near the charge.

• Whether the provider addressed the condition at this visit, or carried it forward from an old problem list untouched.
• Whether the note states laterality, stage, episode of care and whatever other detail the diagnosis set asks for.
• Whether the procedure described in the body of the note matches the procedure named in the plan.
• Whether a signature and a date sit on the documentation, since an unsigned note isn't a record anybody codes from.

Some Epic builds surface AI-suggested codes beside the note, and a coder treats those as a starting point rather than an answer. The suggestion reads the text, never the intent. So a coder verifies each one against what the provider wrote, and drops any code the documentation won't stand behind. That reading is a learned skill, and it separates a coder from a data entry hire more cleanly than a credential ever does.

How does a coder defend a modifier in Epic?

A coder defends a modifier in Epic by pointing to the fact in the record that changes what the base code already claims, then leaving that reasoning where a reviewer can find it. Modifiers aren't levers for getting a code paid. They report something about the service, and the documentation has to back it.

Modifier 25 draws the most scrutiny, because it says the provider did a separate evaluation on the same day as a procedure. The record has to show that evaluation standing on its own, with its own history, findings and decision. Notes where the evaluation reads as the lead-in to the procedure won't carry it.

• Modifiers saying a service was separate from another billed the same day, such as modifier 25 on an evaluation.
• Modifiers naming the side of the body, which the note has to state rather than leave to inference.
• Modifiers splitting a service into professional and technical parts, where the organization owns one part and not the other.
• Modifiers reporting a reduced or discontinued procedure, which the note must describe as reduced or stopped.

Modifier misuse is a standing audit target, so a coder writes down the sentence that justified the modifier while it's fresh. For the wider set of tasks this role owns day to day, see our breakdown of medical coder duties and responsibilities.

How does a coder route a documentation question to a provider in Epic?

A coder routes a documentation question to a provider in Epic by writing a query that quotes what the note says, asks what the provider meant, and offers no answer of its own. Queries that suggest their own answer are worse than no query at all. They put a code in the provider's mouth and leave a permanent record that it happened.

Queries go out when the documentation falls short in one of four ways.

• Conflicting, where two parts of the note name different conditions for the same visit.
• Incomplete, where the note names the diagnosis and leaves out the detail the code set asks for.
• Ambiguous, where the note would support either of two codes and nothing settles the choice.
• Unsupported, where a procedure appears in the plan and nothing in the note describes it being performed.

The query stays part of the record, which surprises an organization the first time a reviewer asks to see the query log. Write it so it reads well a year from now, in plain language. Query and documentation practice belongs to health information management, and the body covering that work is the American Health Information Management Association.

What happens when a coding edit stops a charge in Epic?

When a coding edit stops a charge in Epic, the charge holds in a review status and goes nowhere until a coder answers the question the edit raised. The claim doesn't drop, the payment doesn't post, and the account sits in a work queue with a reason attached to it. A held charge is cheaper than a denied one, because nothing left the building yet.

Four edits land on a coder's desk rather than a biller's.

• A bundling edit, where one procedure code overlaps another procedure code on the same account.
• Medical necessity, where the diagnosis code doesn't support the procedure code under the payer's policy.
• A missing or invalid modifier, where the record justifies a code and the charge went out without it.
• Diagnosis specificity, where the code sits too high in its family for the payer to accept.

The tempting fix is wrong. Clearing an edit with nothing in the documentation behind it turns a held charge into a paid claim and an audit finding at once. Medicare's own coding and billing rules are published by the Centers for Medicare and Medicaid Services, and commercial payers borrow from them unevenly, so a coder reads the plan's policy before rewriting anything.

How does a coder keep the code set current across an Epic build each year?

A coder keeps the code set current across an Epic build each year by reading the changes before they take effect, then checking that the organization's own build carries them. Retired codes never announce themselves. They come back as a rejection weeks later, attached to a charge somebody already counted.

The diagnosis set and the procedure set don't change on the same date, so a coder runs this update twice a year rather than once. Deleted codes, new codes, and codes whose descriptor moved while the number stayed put all land in the same pass. That third kind slips through, because the number still works and now means something different.

• Every deleted code pulled from the favorites, charge lists and preference lists the build carries.
• Every new code the specialty uses added, with the provider briefed on what the documentation now has to say.
• Every changed descriptor read in full, not skimmed for the number at the front of it.
• Every standing edit rechecked, since one that cleared last year may fail under the new code.

A large build touches many specialties at once, so the update runs long. For the wider shape of the job outside any single system, read our medical coder guide.

How does a coder leave an audit trail in Epic?

A coder leaves an audit trail in Epic by recording the reasoning behind each code where the next reviewer can read it, so a decision made today reads the same a year from now. An audit isn't a memory test. Reviewers read what's on the record, and the coder who left a note at the time walks a sample in an afternoon, not two weeks.

Governance sits heavier in a large organization, so the trail carries the same items every time.

• The account as coded, showing every diagnosis code, procedure code and modifier the coder put on it.
• The full clinical note for that date of service, signed and dated by the provider rather than the coder.
• Any query the coder sent and the answer it drew, since the query is part of the record too.
• The coding guideline or payer policy the coder relied on, named rather than described from memory.

Nobody rewrites a note to survive a review. A late addendum is legitimate when it's dated and signed as one, and it's fraud when it's backdated to look as though it was there all along. For the rest of what this job asks of a person, see our rundown of medical coder skills.

What system access does a remote coder need in Epic?

A remote coder needs read access to the complete clinical record and write access to nothing beyond the coding and charge fields, which is narrower than it sounds and wider than most organizations expect. Reading the whole note is the job, and nothing gets coded from a summary screen. Epic is the EHR the organization runs, so the security team, not the coder, decides which parts of the chart the role opens.

• A named account for the coder, so the log shows who opened which chart and when.
• Read access for the coder across the clinical documentation, covering notes, results and orders for the dates being coded.
• Write access for the coder limited to the coding and charge fields, with no rights over the provider's note.
• Multi-factor authentication on the coder's login, with a recovery path that doesn't sit on one phone.
• A revocation step run the day the coder's engagement ends, against every system the coder touched.

Honest Taskers staff do administrative and clinically adjacent work and never give clinical advice or make clinical decisions. Professionals are HIPAA-trained under a dedicated HIPAA compliance officer, a Business Associate Agreement is signed when a professional accesses protected health information, and the company describes its security environment as SOC 2 audit ready. The talent pool includes licensed nurses and physicians, which describes how the company recruits rather than what a placement does. For the closest published occupational description, the Bureau of Labor Statistics writes up medical records specialists in its "Occupational Outlook Handbook" (Bureau of Labor Statistics, 2025), where the listed duties are records, codes and classification systems rather than clinical judgment.

Where does a remote coder fall short in Epic?

A remote coder falls short in Epic in three places worth naming before the job posting goes up, and not one of them argues against the hire.

Platform experience isn't build experience. Somebody who spent two years in Epic elsewhere still needs a week with your charge lists, preference lists and queue rules, because those are local decisions, not vendor defaults. Budget the week instead of discovering it in a backlog.

Credentials don't map neatly onto the two coding streams. A coder strong on professional-fee work isn't automatically a facility coder, and an organization treating the two as interchangeable finds out at the first audit. So ask what the coder has coded, on which side, and for how long.

Narrowing on one platform plus one specialty plus one schedule filters three ways at once, so the search runs long or a criterion gives way. Decide in advance which of the three you'd trade. Honest Taskers recruits in the Philippines, Latin America, India and Pakistan, and its 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, so 20 hours a week runs roughly $800 to $1,012 a month and 40 hours roughly $1,600 to $2,024. New clients may receive a two-week working trial with their first selected professional, subject to current service terms, and replacement support is unlimited. Honest Taskers reports 99.6% average monthly retention, which matters for a coder because a year of coding decisions and their reasoning live with the person. For the questions that separate real system experience from a line on a resume, see our guide to what EHR skills to look for in a virtual assistant.

Where do these Epic coder facts come from?

Honest Taskers rates, recruiting geography, trial terms, retention figure and compliance posture come from the company's published rate card and service terms. Epic appears here as an electronic health record and revenue cycle platform that large health systems, hospital-affiliated groups and ambulatory organizations run, and no module name, menu path, price or customer figure for it appears anywhere, because none of it was read from the vendor. Medicare coding and billing rules come from the Centers for Medicare and Medicaid Services, the occupational description from the Bureau of Labor Statistics, and query and documentation practice from the American Health Information Management Association. Everything about reading a note, assigning a code, defending a modifier and answering an edit reflects general outpatient and facility coding practice, not one organization's protocol. No coding accuracy rate, charts-per-hour figure or turnaround time appears on this page.

Organizations that have settled how the coding work runs and want to compare providers next can start with our ranking of best virtual medical coder companies. It lays out how these firms screen for coding experience, handle protected health information, and structure trials and replacements, which is the practical next question once the role and the queue workflow are clear.

Request candidates with medical coding experience in your specialty and Epic workflows.