You passed the recruiter call, the hiring manager liked you, and then an email arrives: “Here is a short test task, please send it back within a week.” Take-home assignments are common in software development, QA, design, analytics and marketing roles. They can be the fairest part of a hiring process, because you show real work instead of answering trivia under pressure. They can also quietly eat a whole weekend and still end in a one-line rejection.
This guide walks you through the whole cycle: deciding whether to do the task, agreeing on scope, planning your time, building the solution, and submitting it in a way that makes the reviewer’s job easy.
Step 1: Decide whether the task is worth it
Not every assignment deserves a yes. Before you open your editor, answer four questions:
- How far along is the process? A task after a real conversation with the team is a better investment than a task sent automatically right after you applied.
- How big is it really? Read the whole brief and estimate honestly. If the company says “two to three hours” but you count a backend, a frontend, tests and deployment, the real number is likely much higher.
- How much do you want this job? If it is one of your top choices, spending a few evenings on it is reasonable. If it is a backup option, it may not be.
- What else is on your plate? Three parallel assignments plus your current job is a recipe for three mediocre submissions.
A useful rule of thumb: if the realistic effort is more than about a working day and you have not yet spoken to anyone on the team, ask whether a shorter version or a live exercise is possible. Many companies have an alternative and simply do not advertise it.
Red flags worth noticing
- The task looks like a piece of the company’s real product, with real client data or a real backlog ticket.
- There is no clear deadline, no evaluation criteria and no one to ask questions.
- You are asked to deploy something to their infrastructure or sign over rights to your code.
- The scope is huge, and nobody can tell you how it will be reviewed.
One of these is not necessarily a deal-breaker, but two or three together mean you should ask questions before investing your time.
Step 2: Clarify scope before you start
Most weak submissions do not fail because of bad code. They fail because the candidate solved a slightly different problem than the reviewer expected. A short email before you begin prevents that. Ask about:
- Evaluation criteria. What matters most: code structure, tests, UX, performance, or speed of delivery?
- Time expectation. How many hours do they expect you to spend, and is going over that a plus or a minus?
- Constraints. Required language, framework or tools? Are libraries allowed?
- Format. Repository link, archive, deployed demo, slides?
- Next step. Will there be a follow-up call where you walk through the solution?
Here is a template you can adapt:
Hi Anna, thank you for the task, I’m happy to work on it. A few quick questions so I focus on the right things: what are the main criteria you will review the solution against? Is there a rough time budget you expect? And should I send a repository link or an archive? I plan to submit by Thursday evening.
Naming your own deadline is a small signal of reliability. Keep it, or warn them early if something changes.
Step 3: Time-box the work
Once you know what is expected, set a budget and split it into blocks. Here is an example plan for a task the company estimates at four to six hours:
| Block | Share of time | What you do |
|---|---|---|
| Understand | ~10% | Reread the brief, list requirements, write down assumptions |
| Core | ~50% | Build the minimum that fully satisfies the requirements |
| Quality | ~20% | Tests, error handling, edge cases, cleanup |
| Present | ~20% | README, short summary, final check from a clean clone |
The percentages are a rule of thumb, not a law. The point is that presentation gets real time instead of the last ten exhausted minutes.
Two habits help a lot:
- Finish the core first. A complete simple solution beats an impressive half-finished one. Add extras only when the required part works end to end.
- Write down what you skip. Every time you decide not to do something, note it. That list becomes the “What I would do next” section of your README.
Step 4: Build like someone will read it
Reviewers usually have limited time and several submissions to compare. Make yours easy to evaluate:
- Small, meaningful commits. A clean history shows how you think. Avoid one giant commit called “done”.
- Readable names over clever tricks. Optimize for the person reading your code tomorrow.
- A few targeted tests. You do not need full coverage. Test the core logic and one or two edge cases you consciously handled.
- Sensible error handling. What happens with empty input, a failed request, a missing file?
- No secrets in the repo. Use an example config file instead of real keys.
If the task is not about code, the same idea applies. A designer should explain decisions next to the mockups. An analyst should state data assumptions before showing the conclusions.
Step 5: Write a README that does half the selling
The README is often the first and sometimes the only thing a busy reviewer opens. A strong one answers five questions:
- How do I run it? Exact commands, required versions, a single happy path.
- What does it do? A short summary of the implemented requirements.
- What did you assume? Every ambiguity you resolved and how.
- What trade-offs did you make? For example, “in-memory storage to keep the setup simple; a database would be the next step”.
- What would you do with more time? Your list from Step 3.
Add how much time you actually spent. It is honest, it puts the result in context, and it shows that you respect boundaries.
Before sending, clone your repository into a new folder and follow your own README from scratch. This one check catches a surprising number of broken submissions.
Step 6: Submit and follow up
Send a short, friendly message with the link, a one-line summary and a reminder of the time spent:
Hi Anna, here is my solution: [link]. I implemented all required features plus input validation; details, assumptions and next steps are in the README. It took about five hours. Happy to walk you through it on a call.
Then record the submission in your job tracker together with the date and the expected answer time. If a few working days pass beyond what they promised, a polite check-in is appropriate. In Cursopus you can keep each application in its own stage on the Kanban board, so a task you sent last Tuesday does not get lost among fresh applications.
Step 7: Prepare for the review call
Many companies follow up with a session where you present the solution. Prepare as you would for an interview:
- Reread your code the day before. You will be asked why you chose a particular approach.
- Prepare a two-minute overview: problem, approach, main trade-off, what is next.
- Expect a change request: “How would you add feature X?” Think through one or two likely extensions.
- Admit weak spots before they are found. “I know the error handling here is basic; with more time I would…” shows maturity.
If you get rejected anyway
It happens even with strong submissions: another candidate was further along, the role was paused, or the team valued a different trade-off. Ask once, politely, for one or two points of feedback. Not every company will answer, but when they do, it is useful input for the next task. Then keep the project: with permission or if it contains nothing confidential, a well-documented assignment can become a portfolio piece.
Quick checklist
- I know the evaluation criteria and the expected time
- I named a deadline and I am keeping it
- The core requirements work end to end
- Tests cover the main logic
- The README explains running, assumptions, trade-offs and next steps
- I tested the setup from a clean clone
- The submission is logged in my tracker with a follow-up date
Juggling several test tasks and interviews at once? Track every application and its next step in Cursopus.