7 ways to assess programming skills when hiring new developers

When hiring developers, you’ll want to ensure that the new recruit is cut out to do the job. 

It doesn’t make sense to hire an iOS developer, only to find out a few days later that they’ve never touched Swift in their life – contrary to their CV.

In other words, it’s crucial to thoroughly assess candidates’ programming skills and not blindly trust some lines on their resumes. 

This article will show you a few methods about how to do this so that you can ensure you’re recruiting the right people for your team.

Most self-respecting developers will have a portfolio of their previous or current projects. Think about it – you wouldn’t hire a content writer without reading their articles, would you? 

The same logic applies to developers; their portfolio showcases their coding abilities.

In that respect, portfolios are a better medium for assessing a developer’s skills than CVs. 

With a portfolio, you can clearly see the candidate’s development level – the knowledge they’ve acquired and how they’ve implemented it. 

A CV simply can’t present a developer’s skillset as clearly.

In fact, a CodinGame survey showed that 57% of development recruiters might abandon CVs entirely: 

These numbers shouldn’t be surprising; words on a paper simply can’t display competence as well as the real-world examples found in portfolios.

When hiring, examine applicants’ portfolios in the context of your own team’s needs. Look at whether they collaborated with others to see if they’re a team player. 

Consider what tools they’ve used and if your company would benefit from them. 

For example, this developer has experience with developing mobile applications in React Native:

If you’re working on a mobile app using React Native, you’re in luck – one glance at this developer’s portfolio shows that they’re probably a good fit. 

By further diving into their portfolio, you’ll see all their project’s features and can determine the scope of the candidate’s knowledge.

For example, this Fitness app boasts a smartwatch, or wearable device, integration:

Imagine smart device integrations is one of your stakeholder requirements; having this developer’s skills on the team would be invaluable.

In other words, the main benefit of portfolios is that you can see candidates’ previous projects and therefore gauge how helpful they would be for your team. 

Spandana Govindgari expressed this sentiment best:

By examining applicants’ previous work, you can easily imagine them in your environment and assess if their programming skills are the exact skillset you require.

A GitHub profile is similar to a portfolio; you’ll be hard-pressed to find a developer without one. 

The website allows developers worldwide to collaborate on open source projects; it’s an up-to-date, public record of developers’ software solutions.

When assessing a candidate’s GitHub activity, your first stop is their GitHub profile:

A Github profile page provides a complete overview of the user’s website activity and can help assess your applicant’s programming skills.

For example, repositories are particularly pertinent. A repository is essentially a project’s folder; it contains all of the project’s files and also stores revision history. 

By examining these folders, you can see what your candidate is currently working on and also gauge their level of expertise.

The repositories section in a profile will also include forked projects – a personal copy of another developer’s repository. 

Forks allow developers to edit a project without affecting the original upstream repository. By checking your applicant’s forks, you’ll get a feel for the type of projects they’d enjoy working on.

Here’s an example of repositories in a GitHub profile:

This particular profile shows that this developer is Kotlin-focused and seems to focus on libraries. 

If you’re involved with Android development, scanning just this one page would validate this developer as a possible fit.

Another helpful parameter on GitHub is the number of contributions – a log of the user’s GitHub activity. 

To be specific, it’d be best to look at how many commits/pull requests/ or issues your candidate has opened.

Let’s look at our Kotlin developer’s contribution calendar:

This developer is reasonably active, with close to 400 contributions last year. But, more importantly, he’s had seven commits in the past two months. 

Commits represent any edits that the developer made to a repository. 

They represent their contribution to an open-source project and are a perfect method for viewing your applicant’s programming expertise.

Stack Overflow has a similar reputation as GitHub; almost every developer has an account. 

The website is used for asking programming questions and sharing coding solutions and is often a developer’s go-to resource. 

Stack Overflow’s recent survey revealed just how popular the website is:

Considering these numbers, your developer candidates are probably active on the website. So, what exactly should you monitor when checking how applicants use Stack Overflow?

Badges are an excellent place to start. Stack Overflow awards badges for just about anything, but they tend to be reserved for those especially helpful developers. 

For example, you’ll receive a ‘Great Answer’ badge if your answer scores 100 or more. Similarly, the ‘Famous Question’ badge is reserved for questions with 10,000 views or more. 

If your candidate has one of these exclusive badges, you know they’re asking insightful questions and providing helpful answers, proving their programming skills.

Glen Cathey, the author of the Boolean Black Belt blog, has also highlighted the badges’ worth, comparing them to LinkedIn endorsements:

Stack Overflow’s awards carry much more weight than LinkedIn, as they are more heavily regulated. 

Don’t look at LinkedIn for proof of programming expertise; Stack Overflow is the more reliable source.

Besides badges, you should also check your candidate’s actual answers and questions. 

You might find that your applicant has provided high-quality solutions, which is a sure sign of quality programming skills. 

One user asked the following question:

The highest-ranked answer to this inquiry was the following:

This reply received over a thousand up-votes, proving that their answer helped many developers. 

Furthermore, they even took the time to offer an additional update following the release of Swift 3+. Suppose this developer is one of your iOS developer candidates. 

In that case, you’d do well to seriously consider them for the role, as they offer helpful, concise, and up-to-date solutions.

Algorithmic programming tests often have a bad reputation, but don’t turn up your nose at them immediately. 

When combined with other assessments, these tests can be a valuable indicator of developers’ skills.

Algorithmic testing is most relevant when hiring junior developers; for an entry-level role designed for recent graduates. 

These tests confirm a candidate’s abstract analytical skills and a strong Math and CS background. 

If your applicant can solve this test, that’s a sure sign they have a great foundation to work from.

This same sentiment recently received 63 upvotes in a Quora thread:

Good algorithmic knowledge proves a junior developer’s potential, indicating they’ll grow into a highly-proficient developer.

That being said, mid-level or senior developers probably won’t do well on algorithmic tests simply because algorithms aren’t part of their day-to-day workload. 

They are abstract notions that only enter the real-life application in selected circumstances.

Glen McCallum, an experienced engineer, is proof of this: 

For example, algorithms are constructive when scaling a single feature in your system. 

However, that’s a task for a junior developer; a more experienced developer will likely deal with distributed systems.

Consider Advent of Code material if you’re looking for an innovative algorithmic test. 

The website hosts an ‘advent calendar’ (25 days) of programming puzzles that require algorithmic knowledge to solve. 

For example, on day 7 of the 2020 calendar, one airport implemented some complex baggage rules:

At least another 50 lines of rules carry on. The test-takers task is to find out how many bags eventually contain at least one shiny gold bag. 

The easiest method to visualize this fun riddle is building a tree, after which your applicant would ultimately have to utilize a breadth-first and depth-search algorithm. 

These puzzles are a superb, fun method to test algorithmic knowledge and are much more creative than requesting your candidate to write a bubble sort on a whiteboard.

If you want a real-world glimpse of your candidate’s programming skills, try out live pair programming – a coding test you’d complete together with the applicant. 

This allows you to see the candidate’s unfiltered coding in action, and they can explain their coding logic at the same time.

That being said, don’t expect perfect coding solutions from these tests. Jonathan Fernández, a consultant at ThoughtWorks, emphasized this point:

In other words, live pair programming is geared toward assessing code readability and extensibility, getting a general feel for how a candidate approaches tasks. 

Don’t expect flawless coding. 

You can, of course, call in the developer for an on-site pair programming session, but plenty of tools also allow for virtual pair programming. 

For example, HackerEarth’s FaceCode is one such resource.

Explicitly designed for interviews, FaceCode comes equipped with a collaborative code editor and a built-in chat (with video and audio options). 

With this tool, you and your candidate can tackle the task together and easily discuss coding choices. There is even a section for note-taking and scoring, shown below:

This intelligent interface is designed especially for conducting live pair programming interviews. 

You’ll even be able to access a library of pre-prepared programming questions for when you’re truly out of inspiration on what to ask your applicants. The library is shown here:

This resource is especially useful, as you can also create your own library – a location full of programming exercises you want to see your applicants tackle in real-time.

Pair programming as an interview technique has a good reputation, as developers appreciate the opportunity to show their capabilities in a real-world situation; as this Reddit user stated:

For the candidate, pair programming is a taste of what would be expected of them during their workday. For you, it’s a way to assess if their programming skills are up to the task.

You can also provide take-home coding assignments as an alternative to pair programming. 

These assessments also consist of real-world coding tasks, but you aren’t there for the coding; developers are left to their own devices. 

It’s essential that you provide applicants with the same type of environment as your employees have; this includes libraries, frameworks, and even access to GitHub, Stack Overflow, etc. 

Remember, this assignment should more-or-less simulate a typical day at your workplace, and there’s no shame in searching Stack Overflow or GitHub. 

After all, plenty of employees use them on a day-to-day basis. 

Tim Dierks quipped about his own internet usage in this now-famous tweet:

Be fair to your developers; give them the take-home assignment, and tell them to use all the same resources they usually would. 

Some developers might feel ashamed to check these online services, but that external pressure is removed by solving the test at home. 

Candidates will solve the task as they usually would, without outwards pretenses.

Many companies, including Foursquare, are incorporating take-home coding assignments into their hiring process. 

The data platform realized the inefficiency and stress whiteboard tests caused their candidates and exchanged them for take-home coding assignments. 

This Glassdoor review is a testament to that:

The candidate gave an overall positive experience for the interview and described the process as ‘very well planned’ and ‘a great experience.’ 

Despite the lack of an offer, they walked away with a good impression.

If you’re unsure how to design your take-home coding assignments, there are more tools than you can count to assist you. 

CodeSubmit offers endless take-home challenges for your choosing, covering more than 70 languages and frameworks.

Here’s an example:

This particular challenge is testing JavaScript and React, but many other topics are available. The main appeal, however, is that you don’t need to develop the assignment yourself.

Although slightly unconventional, a virtual hackathon is another superb method for assessing programming skills. 

Hackathons are highly cost-effective, as you don’t waste time searching for candidates and then hosting individual interviews. 

Instead, you’re able to test many candidates simultaneously, ensuring almost instant insight into their coding abilities.

This perk is significant when considering the following worrying numbers:

Taking this discrepancy into account, a hackathon is invaluable as it will provide you with an accurate picture of a candidate’s abilities almost immediately.

You won’t even have to put effort into securing a location and reserving a time for your hackathon; you can just host the event online. 

Mercer Mettl Xathon is an online tool that will handle all the technicalities of hosting a virtual hackathon for you. 

Their platform will allow you to connect with a wide range of candidates and assess their domain understanding and coding prowess.

The video below describes how it works:

Utilizing such an online tool will let you gauge the skills of a huge talent pool, increasing your chances of finding a developer that fits your company. 

Furthermore, you can always tailor the hackathon’s requirements to your own specific needs, ensuring you only receive relevant candidates.

And if you organize a creative and challenging hackathon, you’re likely to impress some participants. 

You might even not have to search; it’s very likely developers will come to you, as in the case of this Quora user:

By organizing a quality hackathon, you automatically attract talent. And the best part of their interest is that you’ve killed two birds with one stone. 

You’ve snagged an interview and already have a work sample from the hackathon, meaning you can assess if their programming skills align with your desired level of expertise.

Although a CV isn’t a bad indicator of a developer’s skill set, you’ll want to be 100% certain of their coding abilities before hiring them.

To begin with, don’t just look at the resume; also ensure to examine your candidates’ portfolios. Furthermore, always check out their GitHub profiles and Stack Overflow activity.

If you want to observe applicants’ real-world coding abilities, live pair programming or take-home tests are your best.

Although somewhat uncustomary, you shouldn’t disregard algorithmic programming tests and virtual hackathons as assessment mediums.

Follow these methods, and you’re sure to recruit a high-level, highly competent developer.