skip to content

What does done mean differently in a whiteboard round versus a shared-editor round?

level: juniorimportance: must knowfreq 55%

answer

  1. one problem, three finish lines
  2. ask what the room can verify
  3. no compiler means reasoning is the artifact
  4. a live editor can actually run it
  5. done equals verified against named edge cases

basics

~20 s

At a whiteboard, done means a defended plan: correct approach, stated invariant, complexity, and edge cases named out loud. In a shared editor, done means code that actually runs on the cases you named, including the ugly ones.

solid answer

~50 s

The problem can be identical and the finish line still moves, because each medium grades what it can verify. Give me a restock feed of SKU-and-quantity records and ask for the net quantity per SKU: at a board I am finished when the aggregation plan is on the surface, the invariant is stated, the cost is `O(n)` with `O(k)` extra space for `k` distinct SKUs, and I have said out loud what happens to a SKU whose returns cancel its restocks. Nobody can run it, so the reasoning is the artifact. In a shared editor the machine is right there, so I am not finished until I have executed the code on an empty feed, a duplicate-SKU feed, and a nets-to-zero case, and fixed what broke. Polish is not the currency in either round; verified behaviour is, and only one of the two rooms can verify it for me.

go deeper

for a junior

Recall the one-line rule: a board round grades reasoning you speak, an editor round grades behaviour you execute. Before you say you are finished, name the boundary cases and either trace them or run them.

for a middle

Be ready to explain why the bar moves rather than just that it moves. The medium decides what can be verified, so it decides what an unproven claim costs; walk an interviewer through that reasoning with a concrete small example.

for a senior

Show that you manage your own clock against the format. Reserve execution time in an editor round, choose the simpler design when it leaves room to test, and narrate the tradeoff so the interviewer sees a deliberate call rather than a shortfall.

for a principal

Own the judgment about what each format actually evidences and where it misleads. Be able to argue which signals you trust from a no-execution round, which you only trust once code has run, and how you would compensate when the two disagree.

## One problem, three finish lines Take a single small exercise and hold it fixed: a feed of restock records, each carrying a SKU key and a quantity, some quantities negative because they represent returns. Produce the net quantity per SKU and drop the SKUs that net out to zero or below. The algorithm never changes across formats — accumulate into a keyed total, then filter. What changes, and what candidates routinely misread, is **what the room will accept as a finished answer**. The governing idea is simple: *each format grades what its medium can verify.* A room that cannot execute anything grades your reasoning. A room that can execute grades execution. A format with hours and no interviewer grades scoping and communication. Bringing the wrong currency to the room is the single most common format mistake, and it is invisible to the candidate because the code itself may be perfectly good. ### Whiteboard and other no-execution rounds Here there is no compiler, no test runner, and often no scrolling. The interviewer knows this, which is why they will accept a compact sketch — `totals[sku] = totals[sku] + qty` with an elided guard for the first sighting of a key — as long as you say what the elided part does. What they will not accept is unexamined intent. Finished, at a board, looks like: - the approach named and justified against at least one alternative you rejected; - the loop invariant stated (after processing the first `i` records, `totals` holds the exact net quantity of every SKU seen so far); - the complexity given precisely, including the space term and what `k` is; - the boundary cases enumerated out loud — empty feed, one record, a SKU that appears only as a return, a SKU whose net is exactly zero — and each one walked through the sketch by hand; - a small trace on a three- or four-record example, because a hand trace is the only execution available. The trace is the whiteboard's substitute for running the program, and skipping it is the most expensive omission in the format. Two records and thirty seconds catch the off-by-one that no compiler is present to catch. ### Shared-editor and IDE rounds The same content is necessary but no longer sufficient. The room can now run things, so the bar moves to demonstrated behaviour. Finished means: it compiles or interprets cleanly; you ran it; you ran it on the boundary cases you yourself named; and when a case failed you diagnosed and fixed it in front of the interviewer. That last part is the signal these rounds exist to collect — how you behave when your own code disappoints you is far more informative than a clean first attempt. Two practical consequences. First, budget time for execution, not just for typing; a solution finished at the buzzer with nothing ever run is a weaker submission than a slightly simpler one that was exercised. Second, drive the cases from your own analysis rather than waiting to be handed inputs — announcing the nets-to-zero case and then running it is worth more than the interviewer discovering it for you. ### Take-homes With hours instead of minutes and no interviewer in the room, the medium can verify a great deal — but it verifies it *without you present to explain*. So the bar moves again, to scoping and to written communication: a working core path, a short honest note on what you cut and why, and a documented way to run it and its tests. A take-home is graded as a small delivery, and delivery includes the words around the code. ### The misconception this replaces *Good code is good code, the format does not matter.* It is half true — nothing here excuses wrong code — but it predicts the wrong behaviour every time. It leads candidates to write syntactically immaculate code from memory at a board while never tracing it, and to spend the last ten minutes of an editor round renaming variables instead of running the empty-input case. Both are effort spent in a currency the room does not accept. A quick self-check before you call anything finished: *what can this room verify that I have not yet shown it?* At a board the answer is your reasoning, so speak it. In an editor the answer is behaviour, so run it. In a take-home the answer is your judgment, so write it down.

  • You are five minutes from the end of a shared-editor round with untested code. What do you do?
    Run it. A slightly simpler solution that has been executed on an empty input and a duplicate-key input beats a more ambitious one that has never left the editor. If a case fails, say what you think broke before you start changing lines, then fix the smallest thing. Interviewers grade the diagnose-and-repair loop directly, and an untested submission gives them nothing to grade.
  • Does the whiteboard bar mean syntax mistakes are free?
    Free is too strong; ignored is closer. Nobody counts a missing semicolon or a misremembered signature, because the medium cannot check them and everyone knows it. What is not forgiven is a structural error — a loop that misses the last record, a filter applied before the accumulation finishes — because that is a reasoning defect, and reasoning is exactly what the format is there to measure.
  • How should the finish line differ if the editor round has no ability to execute code?
    Then it is a whiteboard round with better typing, and you should grade yourself that way: trace by hand, state the invariant, enumerate boundaries aloud. Say so explicitly at the start, so the interviewer knows you understand the medium rather than assuming you forgot to test. Announcing the constraint you are working under is itself a signal.

A board round is a design review and an editor round is a smoke test; presenting a lovely design at the smoke test still leaves the machine unproven.

saying these in an interview costs you the question

  • Good code is good code, the format does not matter
  • Never traces the sketch on a small example at the board
  • Spends the last minutes renaming instead of running
  • Treats a compiling program as a tested program
  • Waits for the interviewer to supply the edge cases

context