In 1 minute
- Turn requirements into verifiable behavior and separate obligations, assumptions and optional improvements.
- Assess correctness, readability and quality with evidence proportionate to risk.
- Report executed commands, limitations and next steps; available tests do not guarantee approval.
A technical assessment becomes more concrete when you connect each requirement to evidence in your submission. That might be an executed test, a demonstrated workflow or an explained decision. There is no universal rubric that predicts the outcome of every hiring process. Start with the stated criteria and record what still needs clarification before setting priorities.
This guide helps you review a solution already in progress without promising approval or assuming what an evaluator values. For formats, see the coding test guide. Here, the focus is correctness, readability, interface quality and limitations. By the end, you should be able to explain what you delivered, how you checked it and which risks remain open.
How to interpret technical assessment criteria
Do
- Turn the assignment into verifiable behavior. “Allow a retry after failure” is clearer than “provide a good experience”.
- Criteria should match the actual scope. When requirements conflict, ask which priority should guide the solution.
Avoid
- Adding an entire application to demonstrate effort when the task requests only a function.
- Considering an interface complete merely because isolated function tests pass.
Separate explicit requirements, assumptions and optional improvements. A requirement needs evidence of completion; an assumption needs visibility so it can be corrected; an optional improvement should not conceal unfinished required work. The front-end take-home guide helps plan a project submission. During review, use these categories to prioritize fixes without turning personal preferences into hiring requirements.
- For each requirement, write the expected behavior and a verification method.
- Mark unconfirmed assumptions about data, environment and rules.
- List required unfinished work before optional improvements.
- Confirm tool restrictions and the requested submission format.

Functional correctness and edge cases
Review the contract before multiplying tests. Which inputs are valid? What does an empty collection mean? Does order matter? Should repeated data be preserved? Answers depend on the assignment rather than a universal exercise rule. Choose cases that distinguish plausible interpretations. An edge test is useful when its expected outcome follows a known rule or an explicit assumption.
For interfaces, consider action sequences as well as individual states. Failure followed by success can reveal an old message; a new query during loading can expose data from the previous query. Describe the exact sequence and inspect the final visible result. For platform exercises, the online coding test guidance helps distinguish solution defects from input-format or execution problems.
Readability and maintenance through a small example
Read the code for decisions that depend on hidden knowledge. A name like data may work in a short scope but become unclear when it represents a distant business rule. In the example below, the type identifies cents and the function name says that only paid invoices count. The contract assumes validated values. External validation belongs at an appropriate boundary if it is part of the task.
Review this snippet with an empty collection, a pending invoice and a mixture of both states. Check that the input is preserved too. The implementation makes one pass using a numeric accumulator without rearranging records. This isolated rule does not need a class hierarchy. An abstraction should address a real responsibility rather than simply increase the amount of structure in the submission.
type Invoice = {status: "paid" | "pending";amountCents: number;};export function totalPaidCents(invoices: readonly Invoice[]): number {return invoices.reduce((total, invoice) => {return invoice.status === "paid" ? total + invoice.amountCents : total;}, 0);}
Tests, accessibility and proportionate decisions
Select checks based on behavioral risk. A business-rule test should fail when the rule breaks, not when you rename an internal detail without changing the output. For an interface, check the action and the result a person observes. If a service is simulated, explain what the simulation represents and which integration remains unverified. Test counts alone cannot communicate those boundaries.
Include manual checks for interface work: keyboard navigation, visible focus, control names and understandable error messages. Visual alignment does not establish that an interaction works without a mouse. At the same time, do not add infrastructure or libraries merely to signal concern for quality. Explain choices in relation to the assignment and deadline. Useful review identifies both existing evidence and what that evidence cannot prove.
How to collect evidence and discuss feedback
Prepare a short delivery note covering completed requirements, executed commands, limitations and next steps. If a command failed, describe the failure instead of marking verification complete. Say when a check was not run. The reviewer should be able to reproduce the evidence without reconstructing your intentions. Include setup allowed by the assignment and avoid instructions that depend on files available only on your computer.
When receiving feedback, ask for a criterion-based example: “Which behavior fell short?” or “Where was the decision difficult to understand?”. Compare the response with your evidence before defending the solution. If detailed feedback is unavailable, review a concrete gap with explained exercises and practice again. Do not treat silence, acceptance or rejection as a complete diagnosis of your technical ability.
Solve and reread
For review practice, solve a small task, pause and return as though reading someone else's submission.
Write a finding
Write one finding with the observed behavior, consequence and suggested verification.
Make feedback useful
Avoid a list of style preferences unrelated to the problem. This exercise helps produce comments you can turn into a concrete next action.
Frequently asked questions
What is evaluated in a technical assessment?
Criteria depend on the process and may include correctness, clarity, tests, communication and scope decisions. Ask for the stated criteria and connect each to submission evidence without assuming every team uses the same weights or rubric.
Does passing every test guarantee acceptance?
No. Tests check their implemented cases, while the process may include other criteria. Use results as evidence of specific coverage and review requirements, communication and limitations. Do not assume hidden tests cover every important behavior either.
How should I review my code before submitting it?
Compare the solution with the assignment, run main-path and relevant edge checks, inspect names and responsibilities, and record unfinished work. For interfaces, include keyboard use and error messages. Finally, check whether your instructions let someone else run it.
How can I ask for feedback after a technical assessment?
Ask for a specific example tied to a criterion such as correctness or decision clarity. Keep the question short and use the response to choose a study action. Feedback availability varies; missing detail does not establish what went wrong.
Practice with real tests
Solve front-end exercises in the browser, with the same tests a reviewer would run.
See the exercises