On day one, no backend engineer writes a greenfield service. They open a repository someone else built, get handed a ticket, and have to figure out where the relevant code lives, how it works, and how to change it without breaking three other things. That is the job for months before they build anything from scratch.
We interview them by asking for code on a blank page. The blank page is the one situation they will almost never face. The situation they will face constantly, reading and safely modifying unfamiliar code, is the one we rarely test.
Why the blank-page backend interview misleads
A from-scratch problem measures whether someone can produce a known solution quickly. It is a real skill, but it is a small and unrepresentative slice of backend work. It tells you nothing about the behaviors that actually determine whether a hire is productive or dangerous:
- Can they build a mental model of an unfamiliar codebase fast?
- Do they trace how data flows before they change it?
- Do they respect existing conventions, or bulldoze them?
- Do they understand the blast radius of a change in code they did not write?
Those are the day-to-day skills, and the only way to see them is to give the candidate real code they have never seen.
Drop them into a real repo with a real ticket
The exercise is simple to describe and hard to fake: a running backend service the candidate has not seen, and a concrete ticket. "Users report that canceling an order sometimes leaves the inventory count wrong. Find the cause and fix it."
Good repos and tickets for this share a few traits:
- The codebase is real and opinionated. It has structure, conventions, and a bit of accumulated mess, like the one they will actually work in. A toy repo tests nothing.
- The ticket is grounded in behavior, not "add feature X." A bug or a small behavioral change forces comprehension before code.
- The relevant logic spans a couple of layers, so they have to trace a request or a data flow, not just edit one obvious function.
- The fix is small once understood, but understanding takes real navigation.
This is the backend-specific version of assessing debugging skill, which we cover more generally in how to assess debugging skill. The difference here is the emphasis on navigating an unfamiliar codebase, which is the defining backend skill.
What good navigation looks like
The fix is the last five minutes. The first twenty are the interview. Watch how they orient:
- They find their bearings deliberately. Read the structure, find the entry point, follow the request path. Strong candidates spend the first few minutes reading, not typing.
- They use tools to navigate. Grep, jump-to-definition, following imports. Someone fluent in reading code moves through it quickly and confidently.
- They trace data flow. For the inventory bug, they follow what happens to the count from cancel to persistence, rather than guessing at the first plausible function.
- They form and check a hypothesis. "Cancellation probably decrements here but the retry path skips it, let me confirm" beats poking at random.
- They respect the codebase. The fix fits the existing patterns. They do not rewrite a module to patch one line, and they consider what else calls the code they are changing.
The anti-signal is a candidate who starts editing within the first minute, ignores the surrounding code, and produces a fix that works locally but clearly does not fit the system, with no idea what else it touches.
Scoring comprehension over cleverness
Write the behaviors into a rubric so the panel agrees (see how to write a technical interview rubric):
- Did they orient before editing, or dive straight in?
- Did they correctly trace the actual cause, or patch a symptom?
- Did the fix fit the codebase's conventions?
- Did they consider the blast radius (what else calls this, what tests cover it)?
- Could they explain how the system works, not just what they changed?
A candidate who navigates cleanly, explains the system correctly, and runs out of time before the perfect fix is a stronger backend hire than one who produces a clever patch that ignores the codebase and breaks an assumption elsewhere.
Why we run this in a real environment
Reading code fluency is invisible on a shared document. The signal is the sequence: where they looked, what they searched for, how they traced the flow. That only exists in a real environment with the actual repo and tools.
EasyEnv drops the candidate into a real workspace with the codebase and records the session. The panel can watch how they navigated, which turns "they seemed comfortable in the code" into a concrete record of how they built a mental model of a system they had never seen. Since that is the exact thing a backend hire does every day, it is the most predictive signal you can capture.
The takeaway
Backend work is mostly reading and safely changing code you did not write. Interview for that. Give the candidate a real repo and a real ticket, and score how they navigate, not just the diff.
Test the day-one job, not the one they will rarely do.