Skip to content
DevFlash

Coding test

Front-end take-home test: plan and deliver your project

From the brief to the README: priorities, an initial working version, validation and presentation.

  • 5 min read
  • 5 sections
  • Updated November 2, 2026

This guide is under editorial review.

In 1 minute

  • Delimit requirements and organize a working first delivery.
  • Review empty states, failures, recovery, keyboard use and content on narrow screens.
  • Document execution, tests, decisions and limitations to make review easier.

A front-end take-home test starts with understanding the problem and ends when someone else can run and assess your delivery. In between, you must prioritize work, demonstrate relevant states and record limitations. More files or libraries do not automatically improve a project. Clear, working and verifiable behavior does.

This guide follows a project completed at home, with an agreed deadline and room to document decisions. For comparisons with other coding test formats, consult the general guide. Here, focus on turning the brief into a small, reviewable delivery and reserving time to inspect it from the recipient's perspective.

How to interpret a front-end take-home test

Read the entire brief before creating components. Separate required behaviors, technology constraints and reference materials. An image may show appearance without defining interaction; a sample API may omit failure states. List those gaps and ask specific questions. Asking whether selection must survive a reload is more useful than asking generally what the team expects.

Distinguish the calendar deadline from expected effort. When choices are allowed, record assumptions in the README. A missing answer is not permission to expand the product. For a catalog assessment, authentication and payment belong only if requested. Give the primary flow attention before adding demonstrations of unrelated skills.

Scope and acceptance criteria

Turn each requirement into observable behavior. Replace 'robust interface' with something like 'when the request fails, show a message and allow retry'. That detail helps estimate work and verify delivery. Record exclusions too: real pagination may require an API contract that was not supplied. Document that constraint instead of simulating an unavailable capability.

  • Initial priority: the requested flow works with coherent data and states.
  • Required review: keyboard use, messages, responsive layout and tests for the main risk.
  • Optional improvements: only additions that fit after review and have an explained benefit.

Use technical assessment criteria to review evidence without assuming a universal rubric. If time is short, explicitly choose a smaller delivery. Mark incomplete requirements with their impact and next step. Avoid saying something 'needs polish' when an important action does not work; that obscures both evaluation and follow-up discussion.

Components and the first runnable delivery

Build a complete slice of the flow before spreading work across every screen. For an article page, that might mean loading data, displaying a title and offering retry on failure. Choose component boundaries by observable responsibility. Data transformation need not be mixed with markup, and an element used once need not become a library.

The contract below describes article loading states. It permits empty success and an error message without contradictory flags. It is a modeling example that guides the interface, rather than a complete implementation. In a React coding challenge, also decide who owns the state and which events change it. Explain that choice through the flow rather than personal preference.

type Article = { id: string; title: string };
type ArticleState =
| { status: "loading" }
| { status: "error"; message: string }
| { status: "success"; articles: readonly Article[] };
function articleSummary(state: ArticleState): string {
switch (state.status) {
case "loading": return "Loading articles";
case "error": return state.message;
case "success": return state.articles.length + " articles";
}
}

Keep the project runnable throughout implementation. If the API is unavailable, label sample data clearly and isolate its adaptation in a clear location. Do not present local data as a real integration. Record what would change with the final contract and which tests depend on that integration.

A branch timeline with commit dots merging into a main line, ending at a document with neat lines.
An understandable delivery combines working behavior with documentation that lets others open and assess the project.

States, accessibility and tests before delivery

  1. Check failures

    Review more than the happy path. Open the screen without data, trigger a controlled failure and check recovery.

  2. Use the keyboard

    Move through actions with the keyboard, observing names, visible focus and navigation order.

  3. Test long content

    Try a narrow viewport with long content, not just short sample labels. A screen that looks finished may hide information with realistic data.

Choose tests based on delivery risk. If the central rule calculates availability, check that rule directly. If interaction is the risk, verify the outcome after a user action. Many tests of internal details cannot compensate for a missing primary flow. During final review, run the commands you will give the reviewer and record environment limitations.

README and presentation of decisions

Do

  • The README should reduce the effort required to open the project: include environment requirements, run and test commands, delivered behavior and known limitations.
  • Explain decisions that affect assessment: simulated data, missing persistence or how you resolved an ambiguity. Readers need to understand why a choice suited the task.

Avoid

  • Listing technologies without context.

Check repository access and the exact delivery reference. In a presentation, demonstrate the requested flow first, then a failure and recovery. Connect each limitation with a concrete next step. If the next stage uses a platform, review online coding test preparation, since local setup and editor submission have different operational requirements.

Frequently asked questions

How should I organize a front-end take-home test?

Read the rules, turn requirements into acceptance criteria and implement a complete flow first. Reserve time for error states, accessibility, tests and documentation. Order the work around the brief and the risk in each part.

What belongs in a take-home README?

Include requirements, commands, relevant decisions, completed checks and remaining work. Distinguish real integration from sample data. Explain how to reproduce the main behavior and disclose limitations affecting assessment without vague wording.

What if the take-home asks for too much work?

Discuss expected effort and requirement priorities before expanding the delivery. Propose a verifiable subset and record the agreement. Without an answer, state your scope assumption and what you completed within the deadline.

How should I deliver an unfinished take-home?

Deliver a runnable version, identify incomplete requirements and describe their impact and next step. Report tests that actually ran. Do not promise approval; make the situation clear enough for the reviewer to discuss your decisions.

Practice with real tests

Solve front-end exercises in the browser, with the same tests a reviewer would run.

See the exercises