A take-home caps you at four hours: how do you decide what to cut?
answer
- the cap is part of the spec
- reviewers read submissions, not intentions
- which slice proves competence fastest?
- core path correct, risky boundaries tested
- cut breadth and speculation, never correctness
basics
~20 sTreat the cap as part of the specification. Ship a correct, tested core path and cut breadth: extra features, configurability, and speculative structure. A scoped eighty percent with the cuts stated beats an unfinished attempt at everything.
solid answer
~50 sThe cap is a requirement, not a suggestion, and how you spend it is the thing being graded. On a catalog-import exercise I would first pin the core path — parse the feed, validate rows, aggregate by SKU, report rejects — and get that correct end to end before anything else exists. Then I spend on the parts a reviewer cannot take on trust: tests for the risky logic, especially the boundaries that a careless import gets wrong, such as duplicate SKUs, a quantity that nets to zero, and a malformed row mid-file. What gets cut is breadth and speculative structure: alternate input formats, a seam for a second source, configuration for values nobody varies, any abstraction for a use case that does not exist. Then I write down what I cut and why. An honest, documented eighty percent reads as engineering judgment; a sprawling unfinished hundred reads as an inability to scope.
go deeper
Recall the priority order: a working core path first, then tests on the tricky cases, then anything extra. Respect the stated time cap and write down what you left out.
Explain your cut list and the reasoning behind it — why breadth and speculative structure go before tests, and why a present-but-wrong feature is worse than an absent one that is documented as out of scope.
Demonstrate scoping under a real budget: pick the slice that proves competence, defend it against a fuller but shakier submission, and show that you protected correctness and the boundary tests when time ran short.
Own the tradeoff from the reviewer's side. Argue what a fixed-budget exercise actually measures, why an honest scoped submission is a better predictor of delivery than an exhaustive one, and how you would judge an overrun.
## The cap is part of the spec A take-home with a stated four-hour cap on a catalog-import exercise is not really asking whether you can write an importer. It is asking what you build when the budget is fixed and the wish list is not — which is the everyday condition of the job. Candidates who read the cap as a polite suggestion and submit twelve hours of work usually believe they have shown enthusiasm. From the reviewer's chair they have shown that a stated constraint did not bind them, and they have made their submission incomparable with everyone else's. ### Spend in this order **1. The core path, correct, end to end.** Decide the narrowest thing that is unambiguously the point of the exercise — for an import: read the feed, validate rows, aggregate quantities by SKU, surface the rejected rows — and get it working before anything else exists. A partial pipeline that works from input to output is a submission; four beautifully separated layers with no path through them is not. **2. Tests where a reviewer cannot take you on trust.** Not uniform coverage; targeted coverage. The reviewer will trust that you can loop over rows. They will not trust, without seeing it, that you handled a duplicate SKU appearing in two batches, a quantity that nets to exactly zero, a malformed row in the middle of an otherwise good file, or an empty feed. Those are the tests that carry information. Two tests at the exact boundaries are worth more than twenty around the happy path. **3. Legibility.** Names that say what the thing is, one obvious entry point, and a documented way to run the program and its tests. Reviewers read under time pressure too; anything that costs them ten minutes to figure out costs you more than it saved you. **4. Only then, breadth.** A second input format, richer reporting, a configuration layer. ### What to cut first, and what never to cut Cut **speculative structure** first: the interface with one implementation, the plugin seam for the source nobody asked for, the configurability for values that will never vary. This is the most common four-hour sink and it is invisible to the candidate, because building it feels like senior work. In a scoped exercise it reads as the opposite — an inability to distinguish the requirement from the imagined generalisation. Cut **breadth of feature** next: fewer supported cases, done properly, is a defensible submission. Do not cut **correctness of what you claim to have built**. A feature that is present and quietly wrong is worse than the same feature absent with a line in the notes saying it was out of scope, because the first misleads the reviewer and the second informs them. Do not cut **tests down to zero**. This is the classic wrong trade — dropping tests to fit one more feature. The extra feature adds a little breadth; the missing tests remove the reviewer's ability to believe any of it, including the parts that are genuinely fine. Do not cut **the written record of your decisions**, which is the artifact that converts a truncated submission into a deliberate one. ### Handling the cap honestly If you overrun, say so plainly and say by how much — a note that the core took four hours and you spent forty extra minutes on the boundary tests is a small, verifiable, honest number. Silence about an obvious twelve-hour submission is the version that damages you, because the reviewer can usually tell, and now they are also weighing candour. If the scope genuinely cannot be met in the cap, that is often the exercise's actual question. The strong move is to meet the cap and document the gap; the weak move is to meet the scope and ignore the cap. ### The reviewer's chair Reviewers usually spend far less time reading than you spent writing. They are asking: can this person pick the important part, make it actually work, prove it, and tell me what they traded away. Nothing on that list is *finished everything*. Two submissions arrive; one implements every listed feature with no tests and a half-broken edge case, the other implements the core cleanly with four sharp boundary tests and a short note listing the three things deliberately left out and what the production version would add. The second wins nearly every time, and the candidate who wrote it usually stopped an hour earlier.
- Is it ever right to exceed a stated cap?Rarely, and never silently. If you go over, keep it small and say so with a number and a reason — forty extra minutes spent on boundary tests, for example. Reviewers can usually tell, so an unreported overrun costs you on candour as well as on scoping. Meeting the cap and documenting the gap is almost always the stronger submission.
- Under a hard cap, what is the right level of test coverage?Targeted, not uniform. Skip the happy path a reviewer will take on trust and spend the budget on cases that carry information: a duplicate key across batches, a quantity that nets to exactly zero, a malformed row mid-file, an empty feed. Four tests at the discriminating boundaries buy more credibility than twenty around the obvious path.
- Why is dropping tests to fit one more feature the wrong trade?Because the feature adds a little breadth while the missing tests remove the reviewer's ability to believe anything you shipped, including the parts that are correct. Untested code is unverified code, and an unattended review has no other way to check it. Feature breadth is the cheapest thing to cut; demonstrated correctness is the most expensive.
- What is the most common way strong engineers waste a take-home budget?Speculative structure — an abstraction with one implementation, a seam for a source nobody asked for, configuration for values that never vary. It feels like senior work while building it, and reads to a reviewer as an inability to separate the requirement from an imagined generalisation. Build for the stated scope and note the extension point in writing instead.
It is a sprint with a fixed budget, not a portfolio piece: you are being watched pick the story that ships, not asked to empty the backlog.
saying these in an interview costs you the question
- Treats the stated cap as a suggestion
- Cuts tests first to fit another feature
- Ships a present-but-quietly-wrong feature
- Builds abstractions for a second use case that does not exist
- Submits twelve hours of work without mentioning the overrun
- Assumes a partial submission automatically fails