Coding Assessment Test: Complete Guide (HackerRank, Codility, LeetCode)

A coding assessment test is a time-limited online exercise in which job candidates write, debug, or analyse code to solve a set of predefined problems. The test is administered through a browser-based platform — most commonly HackerRank, Codility, LeetCode OJ, CoderPad, or Pymetrics Code — and your solutions are automatically evaluated against hidden test cases. The result is a numerical score or pass/fail outcome that employers use to filter candidates before investing in live interviews.

Employers use coding assessments because they are scalable, consistent, and reasonably predictive of on-the-job programming ability. A company receiving 10,000 applications for 30 engineering roles cannot interview everyone — the coding test eliminates candidates who cannot write correct, efficient code under time pressure. Unlike résumés, which can be embellished, a coding assessment produces an objective, automated result.

Coding assessments typically appear early in the hiring process — usually after an initial CV screen but before any live technical interview. At some organisations, particularly large tech companies and investment banks, the coding test is the very first step after submitting an application. At FAANG companies (Meta, Apple, Amazon, Netflix, Google), passing the online assessment is a prerequisite for every subsequent phone and onsite interview round.

Who Uses Coding Assessments?

Coding assessments are not limited to pure software companies. They are now standard in:

• Big Tech (FAANG and equivalents): Google, Meta, Amazon, Microsoft, and Apple all use HackerRank or proprietary platforms. Passing a coding test is required before any recruiter call.
• Investment banks (technology divisions): Goldman Sachs Technology, Morgan Stanley Technology, JPMorgan Software Engineering, and IBM all send coding assessments. See our Goldman Sachs aptitude test guide and Amazon aptitude test guide for employer-specific detail.
• Consulting firm technology practices: Deloitte Digital, Capgemini, Accenture Technology, and similar firms use Codility or HackerRank for technology-stream graduate roles.
• Startups and scale-ups: Many use CoderPad for take-home or live pair-programming assessments as an alternative to large-platform tests.
• Fintech and SaaS companies: Stripe, Spotify, Booking.com, and Bloomberg all use Codility or custom platforms for software engineering screening.

Coding Assessment vs Algorithm Contest

It is important to distinguish between a hiring coding assessment and a competitive programming contest (Codeforces, ICPC). Competitive programming values finding the absolute optimal solution under extreme time pressure. Hiring assessments value writing correct, readable, and reasonably efficient code — a working O(n log n) solution almost always scores full marks where an O(n²) brute force may time out on large inputs. You do not need to be a competitive programmer to pass a hiring coding test; you need to be a practised, systematic software developer. See also our guide to online assessment tests for broader context on employer screening.

Five platforms dominate the employer coding assessment market. Each has a different scoring model, proctoring approach, and question library. Knowing which platform your employer uses changes how you prepare and what to expect on the day.

HackerRank is the most widely used coding assessment platform globally. When you receive a HackerRank invitation, you are sent a unique URL that opens a browser-based IDE with a problem statement on the left and a code editor on the right. You can compile and run your code against sample test cases at any time. When you submit, your code is run against the full hidden test case suite and each passing test contributes to your score.

Question Types on HackerRank

• Algorithms & data structures: The core of most HackerRank assessments. Problems require you to implement solutions using arrays, hash maps, trees, graphs, heaps, or sorting algorithms. The problem statement specifies constraints — e.g., input array length up to 10⁶ — which tells you what time complexity is required.
• SQL challenges: Common for data engineering, analytics engineering, and backend roles. Questions ask you to write SELECT, JOIN, GROUP BY, window function, or subquery statements against a provided schema. MySQL and PostgreSQL dialects are both used.
• Debugging: You are given broken code containing syntax errors, logic errors, or off-by-one bugs. You must identify and fix them. No blank-page problem-solving required — useful for assessing attention to detail.
• Project-based (Role-specific): Some HackerRank assessments include a mini-project component — implementing a REST endpoint, fixing a React component, or completing a partially written class. These are common at product companies assessing full-stack engineers.
• Multiple choice / knowledge questions: Some role-specific tests mix coding problems with MCQs on data structures, Big-O notation, or language-specific behaviour. Common for junior and graduate roles.

Role-Specific Tracks

HackerRank offers employer-configurable role-specific tracks including Software Engineer, Frontend Engineer, Backend Engineer, Data Engineer, ML Engineer, and DevOps. The question mix changes by track — a Data Engineer track emphasises SQL and Python data manipulation more than graph algorithms, while a Backend Engineer track emphasises API design and systems thinking over pure algorithmic puzzles.

Companies Using HackerRank

Notable employers using HackerRank for screening include Google, Meta (Facebook), Amazon, IBM, Goldman Sachs Technology, Morgan Stanley Technology, Accenture, Capgemini, and hundreds of mid-market SaaS companies. For finance-sector technical roles, see our guides to the Microsoft aptitude test and Amazon aptitude test for employer-specific expectations.

Codility is the preferred platform of many European technology companies and global fintech firms. Its distinguishing feature is a sophisticated automated scoring algorithm — MaxPerf — that evaluates your solution not just for correctness but for time and space complexity. A correct brute-force solution that times out on large inputs scores significantly lower than an optimised solution, even if both produce the right answers on small test cases.

Codility Scoring (0–300)

Each Codility task is scored on a 0–100 scale. A full assessment typically contains 2–3 tasks, giving a maximum total of 200–300 points. Within each task, the 100 points are divided across test case groups:

• Correctness tests (50–60 points): Standard test cases on typical inputs. A correct solution with any time complexity passes these.
• Performance tests (40–50 points): Large input tests (e.g., arrays of 100,000 elements) with strict time limits. Only efficient solutions (typically O(n log n) or better) pass. An O(n²) brute force will time out and score 0 on performance tests even if logically correct.

This means a partially correct but efficient solution can outscore a fully correct but inefficient one. Understanding this scoring structure changes your strategy — always aim for the correct complexity first, even if your solution has minor edge-case bugs, rather than submitting a working O(n²) solution.

Common Codility Task Types

• Prefix sums: Fast range query problems. Common pattern: precompute cumulative sums to answer range queries in O(1) rather than O(n) each.
• Sorting and greedy: Problems requiring an optimal ordering or selection. Frequently tested with interval scheduling, coin change, and meeting rooms problems.
• Binary search on answer: Problems where the answer is monotonic and the search space can be halved. Common in capacity and allocation problems.
• Stack and queue: Bracket matching, sliding window maxima, next greater element patterns.
• Caterpillar method (two pointers): A Codility-specific term for the two-pointer technique. Used heavily for subarray and subsequence problems.

Companies Using Codility

Booking.com, Spotify, Bloomberg, N26, Klarna, Deloitte Consulting Technology, and many Series B–D fintech startups use Codility. Booking.com is particularly well-known for a challenging two-task Codility assessment as its first technical screen. Bloomberg's engineering roles also frequently use Codility with performance-heavy test cases reflecting their latency-sensitive infrastructure requirements.

Coding assessment problems fall into a small number of well-defined categories. Most employers draw from the same pool of classic problem patterns — mastering these patterns is more effective than trying to memorise individual problems.

Arrays & Strings

The most common category in any coding assessment. Problems include two-sum, longest substring without repeating characters, anagram detection, rotation checks, and palindrome variants. The key insight is almost always to use a hash map or two-pointer technique to reduce O(n²) brute force to O(n). If you can only prepare one category deeply, make it arrays and strings — they appear in roughly 60% of all coding assessments regardless of level.

Trees & Graphs

Binary tree traversal (inorder, preorder, postorder, level-order BFS), lowest common ancestor, and path sum problems are common at Medium difficulty. Graph problems (connected components, shortest path with BFS, cycle detection with DFS or union-find) are common at Medium-to-Hard. Most employers who set graph problems provide an adjacency list — practise parsing this representation in your language of choice before test day.

Dynamic Programming

DP problems are the dividing line between Medium and Hard assessments. The most frequently tested DP patterns are: knapsack variants (bounded, unbounded), longest common subsequence / edit distance, coin change (minimum coins), and climbing stairs / Fibonacci variants. For most graduate and junior roles, true DP problems are rare — but they are standard for FAANG and top-tier fintech.

Structured preparation over four weeks is sufficient to pass most graduate and mid-level coding assessments. The plan below assumes roughly 1–2 hours per day. If you have less time, compress weeks 1–2 into one week and prioritise arrays, hash maps, and BFS/DFS above all else — these cover the majority of questions at Easy and Medium difficulty.

For complementary preparation on aptitude and psychometric testing (often used alongside coding assessments), see our guides on aptitude tests, numerical reasoning, and inductive reasoning.

Strong preparation can be undermined by poor test-day execution. The following tactics are based on the specific mechanics of timed online assessments — they differ meaningfully from general interview advice.

The First 5 Minutes

When the test begins, do not immediately start coding. Read every problem in the assessment first to understand the overall scope. Identify which problem is easiest — start with that one regardless of the order presented. For a two-problem Codility test, quickly scan both problem statements before committing to problem one. Allocate your time explicitly: if you have 90 minutes and three problems, decide upfront how much time each gets, and move on even if you are not finished.

When You Are Stuck

• Write a brute-force first. An O(n²) solution that passes correctness tests is always better than no solution. Submit the brute force, then attempt to optimise. On HackerRank, partial credit is real — even a solution that passes 70% of test cases contributes to your score. On Codility, a correct but slow solution still earns correctness points (roughly 50–60% of the task score).
• Use the examples. Trace through the provided examples manually. If your code produces the wrong output, add temporary print/debug statements to inspect intermediate values. Almost every coding platform allows you to run your code against sample cases before final submission.
• Change your approach after 15 minutes of no progress. If you have spent 15 minutes on an approach and are no more certain it will work, discard it and restart with a different strategy. Continuing to debug a fundamentally flawed approach is the most common source of wasted time.

Edge Cases — Do Not Skip Them

Automated test suites are specifically designed to catch edge cases. Before submitting your final solution, mentally run through: empty input (n=0 or empty array), single-element input, all-same elements, negative numbers (if the problem allows them), maximum constraints (will your solution time out on 10⁶ elements?), and the exact boundary conditions in the problem statement. A solution that passes all sample cases but fails on empty input or maximum constraints is one of the most common failure modes.

Using Remaining Time

If you finish early, use the remaining time to optimise your solution's time complexity, add comments to clarify your intent, and verify edge cases on the sample input. On CoderPad and live interviews, the interviewer can see your code as you type — clean, well-commented code signals professional judgement even if the solution is not yet complete.

Your choice of programming language for a coding assessment should be driven almost entirely by fluency, not perceived prestige or runtime speed. The marginal performance difference between Python and C++ is irrelevant on problems where the bottleneck is your algorithm's complexity, not the constant factor.

Python vs Java vs JavaScript vs C++

• Python: The top choice for algorithm assessments. Standard library includes collections.defaultdict, collections.Counter, heapq, bisect, and functools.lru_cache — all essential for competitive problem-solving. List comprehensions and slicing reduce boilerplate dramatically. The only risk is hitting time limits on very large inputs — if constraints mention 10⁷ or more operations, consider C++ or Java. For 99% of hiring assessments, Python is fast enough.
• Java: Verbose but highly reliable. Strong choice if you use Java professionally and can write HashMap, PriorityQueue, and TreeMap code without looking up API docs. Java's autoboxing between int and Integer is a common source of bugs under time pressure — be careful.
• JavaScript: Appropriate for frontend and full-stack roles where the employer expects JavaScript fluency. Algorithm assessments in JS require manually implementing data structures that Python/Java provide natively — be prepared to implement a heap or a proper queue from scratch.
• C++: The fastest language by runtime and the choice for competitive programmers. The STL provides unordered_map, priority_queue, and set. Appropriate for systems roles and quant engineering positions. Memory management errors (segfaults) are a real risk under timed conditions.

IDE and Environment Shortcuts

Online coding environments are stripped-down — you do not get your local IDE's autocomplete, linting, or refactor tools. Practise in a minimal editor (use LeetCode's built-in editor or Codility's demo environment) so the restricted environment is familiar. Key habits to build:

• Tab completion may not exist. Type method names in full. Practise spelling defaultdict, heappush, heappop, and bisect_left from memory.
• Copy-paste behaviour: Some proctored platforms flag clipboard use. If you need to reuse a utility function, type it again rather than copying from elsewhere — both for proctoring reasons and to avoid introducing bugs from a pasted snippet that doesn't quite fit the context.
• Test before submitting. Always run your code against the provided sample inputs before final submission. This catches syntax errors and off-by-one bugs that would score zero on every test case.
• Avoid importing unnecessary libraries. Stick to the standard library of your language. Third-party packages are usually unavailable in online assessment environments.

For candidates applying to roles that combine coding and psychometric screening, our guides to verbal reasoning tests, game-based assessments, and psychometric tests cover the non-technical components you may face in the same application round.