Codility offers an expansive task library for hiring teams to utilize. Here is an overview of the different types of tasks, how they’re scored, and what roles and skills they can help you assess. 

When creating tests, you can combine different task types to help review your candidates across a range of skills. 

Need help? Contact us at with the job description for which you'd like help creating a test and we'll make some suggestions for you. 

The Codility library assesses: 

  1. Real Life Skills 
  2. Fundamental Programming Skills, and
  3. Technical Knowledge

Real-life skills are assessed through automated tasks which get into the practicalities of working with specific languages and/or frameworks for specific roles. For example React tasks for FE Engineers, Spring tasks for DevOps or .NET tasks for .NET Devs. These tasks are based in real-life scenarios, and replicate slices scenarios common in everyday development.

Fundamental programming skills are those which all developers have, no matter their role, and are assessed through automated, and language-agnostic tasks. For example, Algorithms, Bug-Fixing and Coding. These tasks are based in hypothetical scenarios, and test the foundational principles of programming.

Technical Knowledge is tested through domain-specific multiple choice question sets, designed to give a rounded view into a candidate’s understanding of a specific technology. For example, AWS, Scrum and Git. These question sets are typically made up of 10 questions and are a combination of theory and practise.



This task type is designed to help you assess the .NET skills (C#) of your candidates. Combine these .NET core tasks with other fundamental coding skills tasks (in C# for example, the programming language which powers .NET applications) to allow the candidate to show the full picture of their skills. 

Big data

If your company works with large data sets spread across multiple servers, ensuring your new team mates have strong big data skills is an important consideration in the hiring process. Using our new Big Data tasks, you can screen for these skills early on in the recruitment cycle in CodeCheck, or use these same tasks at the interview stage in CodeLive. 


Blockchain has been getting a lot of press lately both for it's vital role in the rise of cryptocurrencies, and it's growing wider application to businesses at large.
Our first Blockchain task focusses on Solidity, which is a programming language used for writing smart contracts by various blockchain platforms, such as Ethereum.

Data Science

To assess data science skills, we've created a couple of different types of tasks - coding, analysis and multiple choice questions. 

  • How it's scored: Each type is scored slightly differently. Coding tasks and Multiple Choice questions are graded automatically for correctness, whereas analysis tasks are left for you to manually grade based on your priorities. 
  • What it's good for:  Any roles which require some element of Data Science.


In these tasks, candidates will implement a simple web design using HTML and CSS based off a design file. 

  • How it’s scored: These are not automatically assessed, the recruiter or hiring manager is given a view of what the web design should look like, and how the candidate's version renders. You can also download the file to review it yourself, and then you can assign a score manually in the candidate's report. 
  • What it’s good for: These tasks are great for testing entry-level web developers and UI designers who need to know some basic coding principles. 


These are great for screening and interviewing backend, full-stack or web developers working with Python. Django is very popular, easy to learn, yet very extensive. Couple these tasks with an algo (in Python) task for a backend dev, or perhaps a web or design task for a web or full stack dev. The tasks are automatically scored, and hiring managers can playback their candidates' code in the candidate report, or take their solution into a sandbox for further analysis. 


DevOps tasks are designed to help you assess DevOps skills, and they are focused on writing Bash scripts. 

  • How they're scored: Automatically for correctness. 
  • What they're good for: devops, system and linux/unix administrators and other roles that rely heavily on scripting skills


Our QA tasks tackle real life problems, allowing candidates showcase their experience in every day tasks. In these tasks we ask the candidate to apply the knowledge of Selenium to solve an everyday QA problem. Our QA tasks are available only in Java and Robot Framework. They are also scored in an unusual way, you can read more about it here. Depending on the stack your QA engineers are using, we recommend pairing one of these QA tasks with a Coding task in the same language.



Designed to help you get a reliable signal about candidates' technical capabilities without taking too much of their time. 

We recommend using 5 Minute Tasks in pairs or triplets to ensure you get a rounded view of your candidate's technical skills, or in combination with a knowledge-based multiple choice question. 

  • How they're scored: Automatically for correctness. 
  • What they're good for: if you need a shorter screening assessment or if you're in a time crunch and need a reliable signal, quickly. 


These tasks are designed to assess a candidate’s ability to write code that is not only correct, but also optimized. Codility calculates time and space complexity for selected submitted solutions.

  • How it’s scored: We measure for correctness and also performance - how fast the solution runs with big data sets. We measure time, space, both, or neither. Coding style can also be assessed for limited languages.
  • What it’s good for: These tasks are great if you want to measure correctness, performance, and style all at the same time. 


In real life, candidates will need to review and fix buggy code. With Bug-fixing Tasks, candidates get a snippet of code which is working but gives the wrong output for the test cases. The objective is to change (at most 2-3 lines of code depending on the task) the code so that it gives the right output for the test cases. 

  • How it’s scored: We measure correctness to test whether the candidate's bug-fixing changes properly correct the solution. 
  • What it’s good for: These tasks are great for testing Quality Assurance or test engineer candidates. They can also be used if someone wants to check performance in a Test Driven Development environment.


These tasks assess a candidate’s coding ability. The candidate only has to arrive at the solution. It doesn’t matter if the code is optimized or fast because these tasks are only graded for correctness.  

  • How it’s scored: Correctness is verified by at least 6 test case groups. Coding style can also be assessed for limited languages.
  • What it’s good for: The bread and butter of our tasks. Get a sense of how well candidates can code in their preferred language.


Regular Expression Tasks check for candidates' ability to write text strings to search for particular patterns. These tasks are shorter compared to other task types, requiring no more than a few lines of code. Regular Expression Tasks are perfect to use in conjunction with other coding questions from the Task Library.

  • How they're scored: Regular Expression Tasks are automatically graded using Python's Correctness is verified by at least 8 test case groups. 
  • What they're good for: Regular Expression skills are core to every front-end and back-end developer. These tasks show how well candidates can write search patterns in their code.


These tasks assess a candidate’s SQL skills. Codility Supports PostgreSQL as well as SQLite. 

  • How it’s scored: We measure correctness.
  • What it’s good for: Great for any developer who has to write database queries or possess basic SQL knowledge. 


These tasks mainly test front-end candidates' JavaScript skills, but they can also use Jquery to arrive at their solution. Web Tasks focus on typical front-end developer skills like communicating with the backend, handling asynchronous jobs in JavaScript, and injecting responses into HTML pages.

  • How it’s scored: They’re scored based on correctness and in some cases, performance as well.
  • What it’s good for: Great way to assess how good a candidate is at using APIs (Fetch API, XMLHttpRequest).


These are essentially coding tasks, but certain elements are randomized to create different versions of the same task. Unlike our other coding tasks, when you use a variant task, no other client will be able to use the same variant, making variant tasks very hard to plagiarize. Using Variant Tasks, hiring teams can mitigate answer-sharing amongst applicants in your hiring process. 

  • How it’s scored: Only correctness is measured.
  • What it’s good for: Any recruitment cycle where plagiarism or answer-sharing is a concern. We also have a great task randomizer feature which can further mitigate plagiarism. Contact us to find out which is the best solution for you. 


Multiple Choice Questions

Codility offers out-of-the-box Multiple Choice Questions that test for candidates knowledge around Git, Data Science, Java and the Java-based framework, Spring and more

  • How they're scored: Each Multiple Choice Question set includes 10 questions around the subject that are automatically scored and their result is shown on the candidate report card. 
  • What it's good for: When you want to test a candidate's knowledge base on a specific topic quickly and succinctly. 


Codility also gives you your own exclusive library where you can create your own tasks exclusive to your account. To learn more about how to create exclusive tasks, check out the full article here.


Codility has a special library reserved for training. To learn more about how to use Codility for employees, check out the full article here.

If you have any questions about our Task Library, or would like to check what additional tasks may be on offer for you, please contact us at and we'll be happy to help. 

Did this answer your question?