Coding for beginners: how to code your first encounter, step by step

Most people learning to code spend their first few weeks reading about it. They watch the videos, they learn what CPT and ICD-10-CM are, they can recite that coders "translate documentation into standardized codes." Then they open a real note for the first time and freeze, because knowing what coding is turns out to have almost nothing to do with knowing how to do it.

That gap is normal, and it closes faster than you'd think once you stop reading about coding and start coding. So this isn't another overview. It's one encounter, worked from the note down to the codes, with the places beginners get stuck marked as we pass them. If you've already sorted out where to start from zero, this is the next thing your hands actually do.

What's in front of you

Before the encounter, a quick word on the tools, because half of feeling lost as a beginner is not knowing which book answers which question. You work from three, and each one answers exactly one thing.

CPT tells you what was done to the patient: the office visit, the X-ray, the removal of a lesion. ICD-10-CM tells you why, so the back pain or the diabetes or the injury that brought them in. HCPCS Level II covers the leftovers CPT doesn't, mostly drugs, supplies, and equipment. You don't need to master all three today. You need to know that a real visit almost always pulls from more than one, and that keeping them straight is most of the early climb. If any of them still feels like a black box, I've written plain-English tours of CPT and ICD-10-CM you can read alongside this one.

Here's the encounter we're going to code:

Established patient, 52-year-old, seen in the office for a three-week history of low back pain after moving furniture. Provider takes a focused history, examines the back, notes no red-flag symptoms, and diagnoses lumbar strain. Plan is NSAIDs and activity modification, with a note to return if not improving. Total time documented: 20 minutes.

Simple, deliberately. A first encounter should be. Let's turn it into codes.

Step 1: read the whole note before you touch a book

The single most common beginner mistake happens before any lookup: grabbing the first codeable word you see and chasing it. You read "low back pain," flip to the ICD-10 index, and now you're three pages deep before you've even registered that this was an office visit with a documented time.

So the discipline is boring and non-negotiable. Read the note start to finish first. All of it. You're not looking for codes yet; you're building a picture of what happened in the room. Only once you can say in a sentence what the visit was (an established patient came in for back pain, got examined, got a plan) do you start pulling it apart. Coders call this abstraction, and doing it in the same order every time is what keeps you from missing the thing buried in the last line. I go deeper on that workflow in how a visit becomes a set of codes; for now, just trust the order.

Step 2: find what was done (the CPT code)

What was done here is an office visit for an established patient. That's an evaluation and management code, and for a first encounter it's worth knowing that E/M levels aren't picked by gut feel. Since 2021 you choose the level by either the medical decision making or the total time the provider documented.

Our note hands us time on a plate: 20 minutes. For an established patient office visit, 20 minutes lands us at 99213. You didn't recall that from memory, and you shouldn't try to. You went to the E/M section of CPT, found the established-patient office visit range, and matched the documented time to the level. That's the move: the book holds the answer, you just have to know where it lives.

The beginner trap here is assuming a longer, more detailed-sounding note automatically means a higher code. It doesn't. The level is set by what's documented against the actual rules, not by how busy the visit felt. A provider who writes three paragraphs about a routine strain hasn't earned a 99214 by word count.

Step 3: find why it was done (the ICD-10-CM code)

Now the reason for the visit: lumbar strain. This is where beginners most often go wrong, because ICD-10-CM has a two-step lookup that you cannot shortcut, and the shortcut is exactly what feels natural.

You start in the Alphabetic Index, not the main list. Look up the condition, something like "strain, low back" or "strain, lumbar," and the index points you to a code. But that code is a lead, not an answer. You then take it to the Tabular List and read what's actually there: the notes, the required characters, anything that says "code also" or "excludes." Lumbar strain resolves to S39.012 (strain of muscle, fascia and tendon of lower back), and the injury codes in that chapter want a 7th character telling the story of the encounter. For a first visit for this problem, that's the "initial encounter" character. Miss it and the code is incomplete and the claim bounces.

The trap, again, is stopping at the index. The index gets you to the neighborhood; the Tabular List tells you which house, and skipping it is the number-one reason a beginner's code is almost right. Almost right is denied.

Step 4: link them so the claim holds together

Here's the step nobody tells you about until you've done it wrong: the codes aren't a list you gather and staple together. The diagnosis has to justify the procedure. On the claim, your 99213 gets pointed at your S39.012, because this office visit happened because of this back strain. That link is the whole logic of a clean claim. A service with no diagnosis to support it reads, to a payer, like a service with no reason, and it gets declined.

In our encounter the link is obvious: one visit, one problem. Real notes get messier. Picture a patient with three chronic conditions and one new complaint, and now deciding which diagnosis supports the visit, and which are just along for the ride, becomes the actual skill. But the principle never changes. You're not filling separate boxes. You're building one consistent account of a visit that a stranger could audit and agree with.

So our finished encounter comes to three lines: a 99213 for the established patient office visit at 20 minutes, an S39.012A for the lumbar strain coded as an initial encounter, and the two linked so the diagnosis supports the visit. That's a coded encounter.

The traps, collected

If you skimmed the steps, here are the four places that catch nearly every beginner, worth taping above your desk.

First, coding before you've read the whole note. Read first, look up second. Always. Second, picking an E/M level by how the visit felt; the level is set by documented time or decision making against the rules, not by length or effort. Third, stopping at the ICD-10 index, when the index is only a lead and the Tabular List is where the 7th characters and the "excludes" notes actually live. Fourth, forgetting to link diagnosis to service, because an unlinked procedure looks reasonless to a payer, and reasonless means unpaid.

There's a fifth that isn't a step but underlies all of them: if the note doesn't say it, you can't code it. If our provider hadn't documented the 20 minutes and the decision making was ambiguous, the honest move isn't to guess a level. It's to query the provider. Beginners resist that because it feels like admitting they can't do the job. It's the opposite. It's the job.

Where this goes next

One clean encounter feels small, but it's the whole pattern in miniature, and every complicated note is just this with more moving parts. The way you get faster isn't memorizing codes. It's running this exact sequence enough times that it arrives before the effort does, the way sight-reading music speeds up with repetition. Part of that speed comes from your books themselves: a well-tabbed CPT and ICD-10 turn a two-minute hunt into a ten-second flip, which is why I'd point any beginner at prepping your code books properly early rather than late.

From here, the road runs toward a credential, because the coding skill and the job are two different hurdles. What that path costs and how long it takes is laid out in how to become a medical coder. But the coding itself, the part that intimidates people from the outside, is what you just did: read the note, find what was done, find why it was done, link them, and refuse to code anything the documentation won't stand behind.

The fastest way to make that sequence automatic is volume, done in the exam's own format. Our study guide and exam simulator is built for exactly that: 700 practice questions with a written rationale behind every answer and 7 full-length timed mocks, so by the time it counts, coding an encounter feels less like a test and more like a habit.