What belongs in the README you ship with a take-home coding assignment?
answer
- The first file a reviewer opens
- Assume a clean machine, no context
- Scope chosen, and the reason behind it
- Name your gaps before the reviewer does
- One honest line about time spent
basics
~10 sA take-home README should carry run instructions that work on a clean machine, the scope you chose and why, the tradeoffs and known gaps behind it, and roughly how long you spent.
solid answer
~40 sThe README is the first thing the engineer reviewing a take-home opens, so treat it as part of the interview rather than packaging. Start with how to run the project and how to run its tests: exact commands, in order, verified on a clean machine, including any setup or sample data. Then state the scope you chose - which parts of the brief you built, which you left out, and the tradeoff behind each cut. Add a short known-gaps-and-next-steps section, because naming a weakness yourself reads as judgment while letting a reviewer discover it reads as an oversight. Keep it to about a page; a README longer than the code suggests the timebox went into prose. Close with an honest note on time spent.
go deeper
Be ready to name what a take-home README must contain: run and test commands, the scope you chose, the tradeoffs and gaps behind it, and time spent. Write it before you submit, never after you hear back.
Explain the mechanics: clone your own repository into an empty directory and follow your instructions literally, pin any setup or seed-data steps, and keep the document to about a page so a reviewer reads all of it.
Show that you use the README to make a scope decision legible and defensible - the alternative you rejected and why - and that you wrote it as decisions happened rather than reconstructing it at the end.
Own the tradeoff: the README is your only channel for constraints a reviewer cannot see, so decide deliberately how much of a fixed timebox it deserves and how much unbuilt work is worth describing before description starts looking like a substitute for delivery.
## The README is read before the code A take-home is reviewed asynchronously. The engineer who opens your repository usually has the brief, a scoring rubric, a short slot in their calendar, and nothing else. Anything they cannot reconstruct from your README - why a feature is missing, why you picked one shape over another, how to even start the thing - they will either guess at or count against you. That makes the README the highest-leverage file in the submission, and the one most candidates write last, in five minutes, at midnight. ## The sections that earn their space **What it does, in three or four lines.** Restate the problem as you understood it. If your reading of the brief drifted, this is the cheapest place for a reviewer to catch it, and it stops them from grading a correct solution to the wrong problem. **How to run it, on a clean machine.** Exact commands, in order: install, configure, seed any sample data, start, and run the tests. Verify them by cloning your own repository into an empty directory and following your own instructions literally. The most common way a genuinely strong submission scores badly is that it does not start for the reviewer, and a reviewer who cannot start it rarely reads much further. **Scope: what you built and what you deliberately did not.** List the parts of the brief you implemented and the parts you consciously skipped. The skipped list is the more interesting one: it is the only evidence a reviewer has that a gap was a decision rather than an accident. **Tradeoffs and known gaps.** Two or three short entries, each naming the alternative you rejected and the reason - throughput versus simplicity, an in-memory store versus a durable one, retry behaviour you stubbed. This is the section that separates a submission that works from a submission that shows an engineer thinking. **Time spent, honestly.** One line. It lets a reviewer calibrate everything above it, and honesty here is checkable against your commit history. ## A worked example A remote-first analytics scale-up sends a senior data engineer candidate a brief: ingest a directory of messy event files, deduplicate records, and expose a daily aggregate. The brief says it should take about six hours; the submission window is five days. One candidate ships the ingest-dedupe-aggregate path end to end, nine tests, and a README of roughly 350 words: four run commands verified on a fresh clone, a scope section saying the aggregate is computed on read rather than materialised because the brief emphasised correctness over latency, and a gaps section noting that malformed timestamps are dropped rather than quarantined, with quarantine named as the next step. Another candidate treats the five-day window as the budget, asks for an extension, and submits on day nine after roughly 31 hours: a dashboard, a container setup, and a plugin layer nobody asked for. The README is a feature list. The reviewer cannot tell which parts of the brief were understood, cannot tell what was cut, and cannot compare the work against the six hours everyone else spent. Both submissions run. Only one answers the question the brief asked. ## What does not belong An apology tour for unfinished work - state gaps neutrally instead. A restatement of your resume. A wall of architecture diagrams for a six-hour project. Long justifications for the parts you built past the brief; if you overbuilt, the README cannot rescue it, and the extra prose draws attention to the scoping problem rather than covering it. ## A practical habit Write the README as you go, not at the end. Every time you make a decision worth a sentence, put the sentence in the file immediately. At the end you are editing rather than reconstructing, and the tradeoffs you record are the ones you actually made instead of the ones you remember making.
- How long should the README on a take-home submission be before it starts working against you?Roughly a page. Long enough for run instructions, a scope section, two or three tradeoffs and a gaps list; short enough that a reviewer reads all of it in a few minutes. When the README is visibly longer than the code it describes, it reads either as padding or as evidence that the timebox went into writing rather than building.
- Should the README state how many hours you actually spent on the assignment?Yes, and honestly. It lets the reviewer calibrate your output against the stated budget, and it is checkable against your commit history, so an understated figure is a credibility risk rather than an advantage. If you went over, say so in one line and say what you would cut next time.
- Do tradeoffs belong in the README or in comments beside the code?Decisions that shaped the whole submission - scope cuts, storage choices, what you did not build - belong in the README, where a reviewer sees them before reading anything. Local reasoning that only makes sense beside a particular function belongs in a comment there. Duplicating everything in both places just makes the README longer without adding signal.
saying these in an interview costs you the question
- Shipping no README and expecting the code to speak for itself
- Run instructions that only work on the author's own machine
- A README that lists features but never names a tradeoff
- Hiding a known gap and hoping the reviewer does not find it
- Padding the README to disguise a week of work past the brief
- Understating time spent while the commit history says otherwise