Codility Assessment Guide 2026: Question Types, Scoring, and Hidden Tests

Your Codility code compiles. Every example test returns “OK.” Then the final score arrives, and it is much lower than expected.

That result is possible because Codility's visible examples do not count toward your score. They help you understand the prompt, while hidden tests evaluate whether your solution is correct across edge cases and, for selected tasks, efficient on large inputs.

The best preparation is not memorizing one leaked problem. Practice real interview questions with written solutions, review why each solution handles boundaries, and use company-specific interview prep to target the employer that sent your assessment.

Passing Codility's visible examples is a checkpoint, not the final score.

Quick Verdict

A Codility assessment can combine algorithmic coding, bug fixing, SQL, frontend or framework tasks, real-life engineering scenarios, and technical knowledge questions. The employer selects the tasks, allowed languages, duration, and any monitoring settings.

For coding tasks, prioritize three things: correctness within the stated constraints, edge-case coverage, and appropriate complexity. Use Codility's practice environment to learn the interface, then use PracHub for timed practice with realistic company and role context.

What Is a Codility Assessment?

Codility Screen is an online technical assessment used before later interview rounds. According to Codility's candidate guide, an assessment may ask you to write or modify short programs, often around 10–20 lines, or answer technical questions.

The invitation page shows the number of tasks, time limit, and permitted languages. Two candidates can therefore have very different tests even when both links come from Codility.

Codility Question Types You May See

Codility's task library covers real-life skills, problem solving, and technical knowledge. Use the job description to predict which mix is most likely.

Algorithmic and Coding Tasks

These often look like a function with defined inputs, outputs, and constraints. Some coding tasks measure only correctness, while algorithmic tasks can also evaluate whether the solution remains practical as input size grows.

Real-Life and Role-Specific Tasks

A frontend candidate may see React, Angular, Vue, HTML, or JavaScript. Backend, DevOps, data, security, and QA candidates may receive framework, scripting, SQL, data-science, test-writing, or bug-fixing work.

For a data-heavy role, add SQL interview practice instead of preparing only for arrays and graphs.

How Codility Scoring Works

Example Tests Are Worth Zero Points

The Run action checks whether your code compiles and returns the expected output for visible examples. Codility explicitly says an “OK” result does not prove the task is solved. Example cases are for understanding and debugging, not scoring.

Hidden Correctness Tests Determine the Score

After submission, Codility runs assessed test cases that are not shown to the candidate. Its automated scoring guide says library tasks generally contain at least six test cases and often more. Passing more assessed cases produces more credit, although cases may be grouped and task-specific rules can differ.

Correctness tests check whether the solution returns the right result across ordinary inputs and corner cases. A solution that hard-codes visible examples can pass Run and still earn 0%.

Performance Tests Measure Scalability

Selected algorithmic tasks also test time or space efficiency with larger data. A brute-force solution may earn correctness points on smaller cases but lose performance points when it times out or consumes too much memory.

The Overall Score Can Be Weighted

By default, tasks can contribute equally, but an employer may enable weighted scoring so harder or more relevant tasks count more. The company also decides its passing bar and how automated results influence the hiring decision.

Visible examples validate your interpretation; hidden correctness and performance tests produce the assessed result.

What Do Codility Hidden Tests Check?

You cannot see the hidden inputs, but the prompt gives clues. The most useful clues are the input constraints, accepted data types, expected return value, and complexity implied by the maximum size.

Boundary Cases

Test the minimum and maximum allowed input, one element, and empty input only when the stated assumptions permit it. Do not spend time validating impossible data unless the prompt asks you to.

Structural Patterns

Try duplicates, all-equal values, sorted and reverse-sorted input, negative values, repeated characters, disconnected components, or ties when they are relevant to the task.

Scale and Numeric Limits

Estimate the work for the largest input. Watch for nested loops, repeated sorting, recursion depth, integer overflow, and unnecessary copies of large arrays or strings.

A Six-Step Codility Assessment Strategy

1. Read Constraints Before Choosing an Algorithm

A small maximum input may allow a simple solution. A limit in the hundreds of thousands usually signals that quadratic work will not survive performance tests.

2. Build a Complete Baseline

Secure correctness before chasing the perfect optimization. A complete solution that earns partial credit is better than an elegant idea left unfinished.

3. Add Your Own Boundary Tests

Do not rerun only the provided examples. Create small custom cases whose outputs you can verify by hand.

4. Test Patterns That Break Assumptions

Ask what your code silently assumes: uniqueness, positive values, sorted order, connected data, or enough elements. Build one test that violates each unsupported assumption.

5. Check Time and Space Complexity

State the complexity, compare it with the maximum input, and improve the bottleneck if the task measures performance. Keep the correct baseline in mind so optimization does not introduce a new bug.

6. Perform a Final Compile

Verify the language, function signature, return type, imports, and debug output. The whole assessment may end automatically when time expires, so leave a compilable version in the editor.

A disciplined test workflow improves both hidden-test coverage and the quality of your final submission.

How to Prepare Before Test Day

Use Codility's free programming lessons to learn its function-style tasks and practice topics such as arrays, time complexity, sorting, prefix sums, stacks, binary search, greedy algorithms, and dynamic programming.

Then move to PracHub. Attempt a relevant question under a timer, write custom tests before viewing the answer, and compare your complexity with the written solution. Repeat with a recent question associated with the target company.

After the online assessment, prepare for the rest of the loop with system design questions and behavioral and leadership practice.

Codility Timing, IDE, and Test-Day Setup

Codility says assessments commonly last from about 30 minutes to two hours, but the employer sets the exact limit. The timer covers the entire assessment, cannot be paused after you begin, and submits the code in the editor when time expires.

You may use your own IDE only when the assessment policy permits it. Even then, compile the final code in Codility because language versions and libraries may differ. Write portable code and avoid dependencies you have not verified.

Most sessions use the browser interface, while some 2026 invitations may require the Codility App. Monitoring such as paste events, tab switching, webcam, audio, or screen recording is configured by the employer and disclosed before the test when enabled.

Common Codility Assessment Mistakes

The biggest mistake is treating “Run: OK” as a full-score signal. Others include ignoring the maximum input, testing only happy paths, over-validating inputs that the prompt guarantees, and optimizing before a complete solution works.

Time management matters too. Scan every task and any displayed weighting before committing most of the session to one difficult problem.

Codility Assessment FAQ

What is a good Codility score?

There is no universal passing score. Task difficulty, weighting, role, and employer standards vary. Focus on maximizing correct assessed cases rather than comparing your result with an unrelated company's cutoff.

Can I pass the examples and still score 0%?

Yes. Codility states that examples are not part of the assessment score. If the solution fails all hidden correctness cases, it can receive 0% despite showing “OK” for every visible example.

Does every task include a performance score?

No. Every automatically evaluated coding task checks correctness, but performance applies only where scalability is part of the task, especially selected algorithmic or fundamental problems.

Does solving faster improve the automated score?

Codility says completion time does not directly factor into automated scoring. However, the fixed assessment timer determines how much work you can submit.

Where should I practice Codility-style questions?

Use Codility lessons for platform-style exercises. Use PracHub Questions for realistic interview problems, company filters, written solutions, and preparation that continues beyond the OA.

Final Takeaway

The core Codility lesson is simple: visible examples explain the problem, while hidden tests evaluate the solution. Read constraints, build a complete baseline, test boundaries and patterns, and verify complexity before the final compile.

Start with PracHub's real interview questions and written solutions, narrow your practice by company and role, and use Codility's lessons to learn the assessment format. That combination prepares you for hidden tests without losing sight of the interviews that follow.

Official references: Codility's automated scoring principles, task library, candidate scoring guide, Run and OK explanation, and timing guide.