Why Algorithmic Coding Tests
are bad

Published: October 05, 2023 by Anthony V.

State of the industry

In today's tech landscape, algorithmic coding tests have become the go-to method for evaluating developers' skills. They are favored mainly because they are cheap and scalable, making them an attractive choice for companies seeking to assess a large pool of candidates.

However, the question we need to ask is whether this approach truly reflects developers' skills or if it's merely a convenient shortcut.

What does algorithmic coding tests mean?

Before we delve into the issues with algorithmic coding tests, let's first understand what they are.
Algorithmic coding tests are assessments designed to evaluate candidates' coding skills, typically in a high-pressure, time-bound environment. These tests primarily revolve around solving algorithmic and data structure related problems, often with an emphasis on optimization and efficiency.

While they aim to gauge candidates' problem-solving abilities, they tend to miss several crucial aspects of a developer's skill set.

Why you should move away from algorithmic coding tests?
Poor Measurement
Narrow Focus

One of the fundamental shortcomings of algorithmic coding tests is their narrow focus. They mainly assess proficiency in basic programming constructs like data structures and algorithms. While these are undoubtedly essential skills, they represent just a fraction of what makes a competent developer.

Solutions Can Be Memorized

Furthermore, algorithmic coding tests can be aced with a few days of preparation thanks to dedicated websites designed to fasten the learning process (e.g., Leetcode, HackerRank). This narrow window encourages candidates to memorize solutions before going to interviews, creating a misleading representation of their capabilities.

A Waste of Time

Most developers agree on the fact that this method wastes everyone's time. Developers need to invest their time in preparation before the interview because a high score is expected to continue the recruiting process. And enterprises will lose everyone's time by interviewing developers who have just memorized solutions and are not a good fit for the position.

No Relevant Insight

Beyond solving algorithmic puzzles, these tests provide little insight into how candidates approach real-world coding challenges.

Code Quality

In a professional setting, writing high-quality code is mandatory as it determines how well the codebase functions, scales, and maintains over time. It is one of the most important skills a developer can have.
Algorithmic coding tests almost never assess these aspects because they prioritize speed and correctness over code quality.

Design Decisions

Real-world coding tasks require making design decisions. Developers need to be able to understand the pros and cons of every design decision. Which software architecture to use, when to introduce layers of abstraction, how different components of a system interact, design patterns...

Technology Choices

In real-world projects, developers need to choose the right tools and technologies for the task. This involves considering factors like scalability, performance, and maintainability cost.
Algorithmic coding tests never involve these considerations.

Testing Strategy

And as a last example of important skills for developers: Testing strategy. Testing is a fundamental aspect of software development. A good testing strategy can make a huge difference in delivery speed. The more confident you are in your tests, the faster you can ship your product and iterate.
Writing good and maintainable automated tests is a highly valuable skill for developers and is almost never evaluated using algorithmic coding tests.

Nothing tangible to talk about in the following interview

After a candidate completes an algorithmic coding test, what is left to discuss during the subsequent interview? In most cases, there's a lack of tangible topics to explore.
Algorithmic coding tests being surface level do not allow us to have deep conversations to gain insight into developers' true abilities. This penalizes both parties; developers cannot showcase their potential, and enterprises will miss out on top talent and make bad recruiting decisions.

Ideal World

In an ideal world, after a take-home assignment, both parties would be able to talk about it to engage in a meaningful conversation where a developer would explain their thought process, the reasons behind their choices, and the alternatives they considered, while the interviewer challenges them to dive deeper.
Communication on technical subjects is part of the day-to-day job of a developer. The ability to have this kind of conversation in the hiring process would be a huge positive for everyone.

Real-World Task

Instead of abstract algorithmic problems, consider assigning candidates a real-world task that mimics the challenges they would face on the job. This approach allows candidates to showcase their problem-solving abilities in a context that aligns with the actual demands of the role.

For example, if you ask a candidate to create a simple microservice with the following kinds of requirements, you will already have better insights into the candidate's skills than the most advanced algorithmic test:
- Implement a small API specification
- Communicate with a database
- Integrate with an existing system (e.g., another microservice)
- Some simple business logic

If you want to see an example of a complete coding test, refer to the Example

Building a complete service from scratch allows developers to showcase all their skills and reflects how they would perform on the job. To increase accuracy, ask candidates to use the tech stack your team currently uses for the job, for example, Java 17 with the Quarkus framework, PostgreSQL database, JSON and gRPC API...

By doing so, you could have a crystal clear view of a developer's true skills, and you would have something tangible to talk about in the following interview. Also, this kind of coding test doesn't need any preparation from the developer because it's part of their day-to-day job, and it's way more fun to do than boring algorithmic tests.

Scalability Problem

Real-world coding tests are known to be the best for assessing skills but are not scalable because they involve a human to assess candidates' code, making it difficult to scale the number of candidates.

But at Codigrade, we solved this problem by fully automating the deployment and evaluation of candidates' services in a live production environment; no human intervention is needed.

Our Solution

Codigrade is a coding assessment platform using real-world coding tests.
All of our coding tests require candidates to create a real microservice from scratch. Their microservice will be automatically deployed and evaluated in a live production environment, we take care of the whole evaluation process.
This assessment method allows us to test skills that would be impossible to test with traditional algorithmic coding tests. Thanks to this strategy, we can provide accurate data about your candidates' skills, helping you to avoid costly hiring mistakes.

Try it now by creating an account here: https://portal.codigrade.com/signup