skip to content

questions

5

What does a work-sample interview round test that a from-scratch algorithm round does not?

level: juniorimportance: must knowfreq 64%

answer

  1. The editor is not empty
  2. Mirrors the first week of the job
  3. Existing code, not invention
  4. Reproduce, minimal change, verify
  5. Formats: pair, fix-the-bug, review, test-first

basics

~20 s

A work-sample round hands you existing code — a repository to pair on, a seeded bug to fix, a change to review — and scores day-one effectiveness: orienting, verifying, collaborating. An algorithm round scores invention from an empty editor.

solid answer

~40 s

Work-sample rounds are built to mirror the job rather than a puzzle. The common formats are pair-programming on a running codebase, a fix-the-bug exercise where the interviewer hands you a seeded repository and one failing test, a code-review round on a change someone else wrote, and a test-driven work sample where you grow behaviour test-first. What they measure is different from an algorithm round: how fast you orient in code you did not write, whether you reproduce before you theorise, whether your change is small and verified, and whether you stay legible to the person sitting with you. Cleverness earns little here; a candidate who reproduces the failure, makes the failing case pass with a minimal change, re-runs the suite and says what they would do next scores well even without an elegant trick.

go deeper

for a junior

Know the four common formats by name and be able to say what each one puts in front of you. Practise on a small project you did not write until running an unfamiliar build and test suite feels routine.

for a middle

Be ready to explain why these rounds predict job performance better than a puzzle: they score orientation, evidence and verification rather than invention. Show that you separate a fix from cleanup.

for a senior

Demonstrate that you can land a defensible change in unfamiliar code inside the session and say what you deliberately left undone. Interviewers at this level watch for restraint as much as for speed.

for a principal

Own the tradeoff between fidelity and fairness when a team chooses this format: a work sample predicts day-one effectiveness but costs interviewer time, is harder to calibrate across panels, and can disadvantage candidates unfamiliar with the tooling unless the setup is provided ready to run.

## What a work-sample round is A work-sample (or practical) round replaces the blank editor with a real artefact. Instead of asking you to invent an algorithm, the interviewer gives you something that already exists and watches how you operate on it. Four formats cover almost everything you will meet: - **Pair-programming on a live codebase.** You and an interviewer sit in one session on a small but real project and add or change behaviour together. - **Fix-the-bug in a seeded repository.** The interviewer hands you a checked-out repository and one failing test that encodes the bug. Your job is to make that failing case pass without collateral damage. - **Code-review round.** You are given a change someone else wrote — often with one or two defects planted in it — and asked to review it aloud. - **Test-driven work sample.** You are asked to grow a small piece of behaviour with tests leading the code, so the interviewer can watch your feedback loop rather than your final answer. ## Why companies run them Algorithm rounds are cheap to run and easy to compare, but they answer a narrow question: can this person invent a solution to a self-contained problem under time pressure? Most engineering work is not that. It is landing in a codebase you did not write, reproducing something a user reported, changing as little as possible, proving that you did not break the rest, and explaining it to a colleague. A work-sample round asks that question directly, which is why it is common at product companies and scale-ups where the first weeks of the job look exactly like the exercise. The format also tends to be fairer to candidates who work well and think out loud but freeze at a whiteboard, and it is harder to prepare for by memorising patterns — the repository is unfamiliar to everyone. ## What the rubric actually rewards Across all four formats the scored dimensions rhyme: | Dimension | What a strong candidate does | |---|---| | Orientation | Runs the build and the test suite before reading everything; finds the entry point from the failing test | | Evidence | Reproduces the failure and forms a hypothesis from output, not from a guess about what is wrong | | Change size | Makes the smallest change that turns the failing case green; separates cleanup from the fix | | Verification | Re-runs the whole suite, not just the one test; checks the neighbouring cases | | Collaboration | Says what they are doing and why, and takes a correction without losing the thread | ## A concrete picture Imagine a developer-tools vendor that sells a build-analytics service. The round is a 75-minute pairing session with a senior test engineer from the team. She shares a repository you have never seen, points at one failing test, and says the reported symptom is that a nightly rollup occasionally reports the wrong total. There is no puzzle to invent. The whole exercise is: run it, see it fail, read the test to learn the intended behaviour, follow the failure into the code, change a few lines, re-run everything, and describe the follow-up you would open. The most common way to lose this round is to decide the seeded code is badly written and start rewriting it. The candidate who reorganises the module has, at the buzzer, a half-migrated repository, a failing suite and no evidence that they can be trusted with a production defect. The candidate who lands a five-line fix with the suite green and says which structural weakness they would tackle next scores far higher — and has said the same thing about the code, without the wreckage. ## How to prepare Practise on code you did not write. Clone a small open project, pick an open issue, reproduce it, and time yourself from first clone to a green suite. Get comfortable running an unfamiliar build and test command inside the first few minutes, reading a test as a specification, and narrating a hypothesis before you change anything. Rehearse the sentence you will say when time runs short: what is done, what is verified, what you would do next. That habit is worth more than any pattern you could memorise, because it is the same habit the job needs.

  • Which of those formats is hardest to fake with rehearsed preparation, and why?
    The fix-the-bug round in a seeded repository. Nobody has seen that codebase before, so no memorised pattern helps; what shows is whether you reproduce before theorising, follow evidence into unfamiliar code, and keep your change small. Pairing is next hardest, because the interviewer sees the working process rather than the result.
  • If you finish the exercise early, what do you do with the remaining time?
    Strengthen the evidence rather than add features. Re-run the full suite, add a test for the neighbouring case the original test did not cover, read your own change back for anything you would flag in review, and then offer the interviewer a short summary plus the follow-up work you would open. Volunteering an unrequested refactor with minutes left is the weaker move.
  • How much should you ask about the codebase before you start touching it?
    Ask for the things you cannot discover cheaply — how to run the build and the tests, whether the repository state is clean, whether anything is deliberately out of scope. Discover the rest yourself; asking the interviewer to explain the architecture reads as wanting the answer handed over, and the round exists precisely to see you orient unaided.

saying these in an interview costs you the question

  • Rewriting the seeded codebase instead of making the failing case pass
  • Reading every file before running the build or the tests
  • Treating the round as an algorithm puzzle and optimising complexity nobody asked about
  • Changing code before reproducing the reported failure once
  • Working in silence, so the interviewer sees only the final diff

context

open as a page

In a fix-the-bug round on a seeded repository, what working sequence do interviewers score highest?

level: middleimportance: must knowfreq 57%

basics

~20 s

Reproduce the failure first, read the failing test as the specification, localise with evidence rather than guesswork, make the smallest change that turns that case green, then re-run the whole suite and say what you would follow up. Diagnosis before edits is the scored part.

open as a page

In a code-review interview round, how should you prioritise the comments you raise on an unfamiliar change?

level: middleimportance: should knowfreq 43%

basics

~20 s

Work outside in: correctness and data-safety defects first, then missing tests and unhandled edge cases, then interface and naming clarity, and only then style. Say the pass order aloud, phrase uncertainty as a question, and finish with an explicit verdict.

open as a page

How do you budget a 75-minute pairing round on a repository you have never seen before?

level: seniorimportance: should knowfreq 49%

basics

~20 s

Spend the first ten minutes getting the build and tests running and reading the failing case, the long middle on one verified change, and reserve the final eight minutes for a full suite run and a spoken summary.

open as a page

In a pairing round you spot a structural flaw behind the seeded bug — do you patch narrowly or restructure?

level: principalimportance: nice to knowfreq 31%

basics

~20 s

Default to the narrow, verified fix and name the structural flaw as follow-up work you would open. Restructure only when the minimal change would be a knowing hack, the larger one is provable in the time left, and the interviewer confirms the scope is open.

open as a page