A Codility test is a timed, browser-based coding assessment that an employer sends you as a link. Codility says most assessments last between half an hour and two hours and contain several tasks: short programs you write (usually 10 to 20 lines), existing code you modify, or technical questions. When you submit, or when the timer runs out, your code runs against hidden test cases that score correctness and, on algorithmic tasks, performance on large inputs. The example test you can see doesn't count toward your score.
This guide is built from Codility's own candidate FAQ, help center and practice site, checked in October 2026. The employer configures each test, including the tasks, the time limit, the languages and the rules, so the intro page behind your invitation link is the final word.
What's in a Codility test
| Task type | What you do | How it's scored |
|---|---|---|
| Algorithmic tasks | Implement a function from a written problem statement with examples and stated assumptions, such as the range of N | Correctness tests plus performance tests on large inputs |
| Code modification tasks | Fix or change existing code. Some tasks limit how much of the initial code you may edit, because they test making as few changes as possible | Hidden test cases; edit limits where stated |
| Real-life tasks | Practical tasks whose requirements are all listed in the description | Tested against those requirements, and you can see how many tests passed |
| QA tasks | Write test cases for a page against its acceptance criteria | Your test suite must first pass a version of the page that works correctly, or the task scores zero |
| Technical questions | Answer questions about a technology | Varies by test |
Codility says the tasks in your test were chosen to reflect skills the role needs, so a backend test and a frontend test can look very different. Its public practice library hints at the range, with exercise sets for SQL, frontend, data structures and bitwise operations alongside algorithms.
Timing and rules, from Codility's candidate FAQ
Codility's FAQ for candidates answers most of the questions people search for. The ones that change how you should behave:
- You can look before you start. Opening the link shows the employer's assessment policies, the number of tasks, the time limit and the allowed languages. Nothing starts until you press Start, so read it all first.
- The timer can't be paused. It covers the whole assessment, not each task, so plan one uninterrupted sitting. You must start within the testing window the employer sets; Codility suggests finishing within a day or two of the invitation and contacting the administrator if you need longer.
- Speed doesn't add points. Codility says the time you take doesn't factor into automated scoring and that tests are designed to leave enough time for every task.
- Your code saves automatically. You can move freely between tasks. Pressing Submit locks that task, and when time runs out, whatever is in the editor is submitted for you.
- Work on your own. You may not consult other people. Whether other resources, or your own IDE, are allowed depends on the policies in your test link.
- Standard libraries only, unless the task says otherwise. Keep the function signature exactly as given; adding helper functions and imports is fine.
- Don't validate the stated assumptions. If the task says N is between 1 and 100,000, you don't need code that checks it.
- Monitoring depends on the employer. Some tests require camera access or screen activity tracking, and the platform asks your permission. Some require the Codility App; otherwise a recent version of a supported browser is all you need.
- If your connection drops, contact the test administrator and ask them to reopen your session. The decision is theirs.
Codility also says its platform meets WCAG 2.2 AA guidelines, works with screen readers and keyboard navigation, and offers an accessibility mode with up to 400% zoom. If you need extra time or another accommodation, ask the employer before you start. Take the assessment yourself and follow the employer's rules — use CoPilot Interview to practice beforehand.
How Codility scores your solution
| Part | What Codility says it measures | What it means for you |
|---|---|---|
| Compilation | A final submission that doesn't compile can't be assessed and earns no points | Press Run often, and never leave broken code in the editor near the end |
| Correctness | Correct results on moderate-size inputs, including corner cases | Test empty, single-element, negative, duplicate and boundary inputs yourself |
| Performance | Running time on increasingly large inputs, based on Big-O, on tasks that ask for an algorithm | Match your complexity to the stated range of N |
| Test count | Every task has at least six test cases; the task score is the share you pass, so 6 of 10 is 60% | Partial credit is real. A correct brute force beats an unfinished optimal one |
| Style | Usually not scored automatically, though some tasks score it and teams may review code by hand | Use clear names and simple structure anyway |
Two FAQ answers explain most surprise results. Pressing Run and seeing "OK" only means your code compiled and passed the example test. And a score of 0% after passing the examples happens because the example tests aren't part of the assessment; the hidden tests cover the edge cases. Codility's help center for employers adds that the overall score combines correctness and performance with a similarity check indicator, that employers can adjust task scores by hand, and that the employer decides what score moves you forward. Some employers share results with candidates, and others keep them confidential.
A worked example of why performance matters
Codility's free TapeEquilibrium task asks you to split an array at position P and minimize the absolute difference between the sum of the left part and the sum of the right part. The obvious approach recomputes both sums for every split, which is O(N²) and far too slow on the large inputs the performance tests use. The faster approach computes the total once and keeps a running left sum, so the right sum is just the total minus the left: one pass, O(N). In Python the core is a loop like left += A[p - 1]; best = min(best, abs(2 * left - total)). Both versions pass the small example and the correctness tests, but only the second passes the performance tests. That gap is the difference between a partial and a full score.
Codility's free practice: lessons, exercises and the demo
Codility publishes free training on its programmers site. The Codility Lessons are 17 topics, each with reading material as a PDF and practice tasks labelled easy, medium or hard. There are also nine exercise sets (bitwise operations, frontend, data structures, SQL, coding skills, algorithmic skills, and past contests from 2015, 2016 and 2017), and a demo test with one task in 30 minutes that shows you the real interface. The demo lists 20 languages, including C, C++, C#, Go, Java, JavaScript, Kotlin, PHP, Python, Ruby, Rust, Scala, Swift and TypeScript; your own test may allow fewer.
If time is short, here is our suggested order, starting with the fundamentals most algorithmic tasks lean on:
| Priority | Lessons | Tasks to start with |
|---|---|---|
| First | 3 Time Complexity, 4 Counting Elements, 5 Prefix Sums, 6 Sorting | TapeEquilibrium, MaxCounters, MissingInteger, PassingCars, GenomicRangeQuery, Distinct |
| Next | 7 Stacks and Queues, 8 Leader, 9 Maximum Slice, 15 Caterpillar Method | Brackets, Fish, Dominator, MaxSliceSum, MaxProfit, CountDistinctSlices |
| Then | 14 Binary Search, 16 Greedy, 17 Dynamic Programming | MinMaxDivision, MaxNonoverlappingSegments, TieRopes, NumberSolitaire |
| If time allows | 1 Iterations, 2 Arrays, 10 to 13 (primes, sieve, Euclidean algorithm, Fibonacci) | BinaryGap, CyclicRotation, OddOccurrencesInArray |
Our pattern guides pair well with the lessons: sliding window, two pointers, binary search, greedy algorithms and dynamic programming.
A two-week preparation plan
| Days | Focus | What to do |
|---|---|---|
| 1–2 | Interface and complexity | Take the demo test. Read Lesson 3 and learn to read N's range as a complexity budget. The Big-O cheat sheet and complexity visualizer help. |
| 3–6 | First-priority lessons | Lessons 4 to 6 and 3: two or three tasks a day. Before submitting, write your own edge-case tests in the test-case box. |
| 7–9 | Next-priority lessons | Lessons 7, 8, 9 and 15. Aim for full correctness and performance, not just a passing example. |
| 10–11 | Harder topics | Lessons 14, 16 and 17, plus one exercise set that matches your role, such as SQL or frontend. |
| 12–13 | Timed simulations | Pick unseen tasks matching the number of tasks and the time limit in your invitation. No notes, no searching, one sitting. |
| 14 | Logistics | Reread the intro page and rules, check your browser and any camera requirement, and plan a quiet block with margin. |
Common mistakes that cost points
- Treating "OK" as solved. It only covers the example. Test the edges yourself.
- Ignoring the stated range of N. A nested loop on 100,000 elements usually fails the performance tests.
- Changing the function signature. The grader can't run your code if you do.
- Ending with code that doesn't compile. With a minute left, revert to your last working version instead of saving a half-finished edit.
- Overflow. Sums of large values can exceed 32-bit integers in Java or C++; use 64-bit types.
- Pasting from another editor without pressing Run. If your test allows your own IDE, Codility warns its compiler may differ from yours.
- Pressing Start too early. Read the intro page whenever you like, but start only when you have the full block free.
- Sinking all your time into one task. The limit covers every task, and partial credit on each beats a perfect score on one.
AI and the Codility test
Codility's help center describes a built-in AI assistant called Cody that employers can switch on in a test's settings. When it's on, candidates can ask it to clarify the task or request documentation-style examples, and the hiring team can read the full transcript of that conversation. If your test doesn't offer it, AI isn't part of your assessment, and outside AI tools fall under the employer's rules on outside resources.
Before the test, AI is a reasonable study partner: ask it to explain a lesson's reading material or to critique a solution you've already written. After a Codility screen you'll usually face live interviews, where you explain your code out loud. A free AI mock interview in CoPilot Interview helps you practice that: it reads coding and technical questions aloud, gives you time to think because coding questions never auto-submit, and scores each spoken answer out of 10 with what to fix. If your Codility test is for Microsoft, our Microsoft online assessment guide covers what candidates report there, and our CodeSignal and HackerRank guides cover the other common platforms.
Get ready for the interviews after the test
CoPilot Interview's free Mock Interview builds questions from your résumé and the job description, reads them aloud and scores each spoken answer out of 10. You get 15 free minutes every day, with no credit card.
Try a free AI mock interviewFAQ
How long is a Codility test?
Codility says most assessments last between half an hour and two hours. The employer sets the exact limit, which is shown on the intro page before you start and covers the whole test, not each task.
How is a Codility test scored?
After you submit, your code runs against hidden test cases. Codility scores correctness on moderate inputs, including corner cases, and on algorithmic tasks also scores performance on large inputs. Code that does not compile earns no points.
Why did I score 0% when my code passed the example?
The example tests are not part of the assessment. Your score comes from hidden tests that cover edge cases and larger inputs, so a solution can pass the example and still fail them.
Can I pause a Codility test?
No. Once you press Start, the timer runs until the end. You can open the link earlier to read the instructions, and your code saves automatically if your browser closes.
Can I use Google, my own IDE or AI during a Codility test?
Only what your test's policies allow. Codility says you must work on your own, that other resources and your own IDE depend on the employer's rules, and that some employers switch on its built-in assistant, Cody.
Does finishing faster improve my Codility score?
No. Codility says the time you take does not factor into automated scoring. Use the time to test edge cases and improve complexity.
How should I practice for a Codility test?
Take Codility's free demo test, work through its Lessons starting with time complexity, counting elements, prefix sums and sorting, and finish with timed simulations that match the task count and time limit in your invitation.