How to evaluate developer skills and hire the best talent

Branimir Hrzenjak
Author
12 minutes
Reading time
Hiring
Category

There are more developers out there than ever, but companies are still struggling to find the ones most suitable for their teams.

If you’re in the same boat, wondering how to evaluate developer skills, don’t worry; we have a lifeboat for you.

We’ll guide you through crucial areas you need to assess in candidates and recommend some evaluating methods. After you determine which of them works best for your agency, each new hiring process will be smooth sailing.

Check out their portfolio

There’s no better starting point for evaluating developer skills than reviewing their portfolio. The portfolio shows you the exact range of somebody’s coding skills, more accurately than a mere description of their previous roles ever could.

In some industries, the end product is all that matters. The process that has led to it—not so much.

However, the software engineering industry is not one of those. Here, the code matters as much as the final product because the lines of code must be understandable to whoever joins the project.

Bug and crash reporting tool for your mobile app.

Portfolios are a great tool to determine the level of expertise of a developer you’ve attracted to apply for a position at your company. They include links to the source code of smaller projects, apps, or libraries written by the developer, usually hosted on GitHub. 

Here’s an example of a developer’s code shown on GitHub.

The following image shows one of Ellen Shapiro’s GitHub repositories.

Shapiro, a mobile developer, created an app similar to Instagram as a personal project to demonstrate how to set up a tool for managing the distribution of Swift code.

Source: GitHub

The usability of apps attached to the portfolio shouldn’t matter; they usually serve the purpose of demonstrating coding abilities.

Taking portfolios into consideration can help you notice the talent that hasn’t been discovered yet.

Some candidates may not have a lot of formal experience and are therefore overlooked by employers. However, a glance at personal projects they’ve programmed independently can show you their proactivity and potential.

For instance, front-end engineer Syk Houdeib got his first developer job without a degree, coding boot camps, or experience.

He pushed everything he did while self-educating to GitHub, which was enough to convince the tech team to invite him to an interview.

“GitHub is your resume, your portfolio, your work experience, and everything you know about code rolled into one.”

Everyone can claim they’re a skilled engineer. Rather than trusting resumes and cover letters, portfolios give you direct grounds to evaluate someone’s coding expertise.

Some candidates also include the link to their StackOverflow profiles in their application and their activity on this platform can help you gain insight into their programming skills. 

For example, you can see the questions they’ve asked other developers and the answers they provided to other community members, which can help you assess both their knowledge and some of their soft skills.

Of course, if you’re looking for a senior developer, relevant experience is imperative. But if you need to fill a junior position, you shouldn’t dismiss the applicants’ portfolios.

Assign sample coding tests

Sample coding tests are an objective way to evaluate developer skills. However, to increase the neutrality of the process, try to remove as many stress factors as you can. That way, you’ll get the most accurate assessment.

Remember that one high-school teacher who made you hate the subject they taught?

It probably took you years to realize that geography is not all that bad; it was just the poor approach Mr. Smith took to teaching.

Well, sample coding tests have suffered a similar fate.

Tracy Phillips, a dev recruitment professional, claims that take-home tests sometimes get an unjustified bad reputation because of poorly-implemented ones.

Based on the reactions of candidates who have gone through inadequate code testing processes, Phillips identifies three flaws:

  • Take-home tests are perceived as free labor
  • They take too much time
  • Candidates rarely get feedback

However, just because some companies have a wrong approach to sample coding tests doesn’t mean you should miss out on such a helpful tool for evaluating developer skills.

You can take Phillips’ comments as a guideline for what to avoid if you decide to try using coding tests.

For instance, while you should strive to create a test that closely resembles projects at your company, you should never assign candidates to work on the actual code you’d use—that could be considered exploitative behavior.

Instead, when sending the test, explain to the candidate that their code will never be used for a project, and that its only purpose is to test their skills in a relevant environment. 

To combat the free labor prejudice, some companies even pay candidates for coding challenges.

MindsDB, a machine learning company, pays candidates who take coding challenges to show that they value the candidate’s time.

This also works as an incentive to encourage candidates to put in as much effort as they would if they really worked for the company.

Source: Shake

However, paying each candidate makes sense only if you are not testing hundreds of them. 

Next, to get a more precise idea of their talents and skills, consider giving candidates access to the same tools and libraries your developers use.

Also, don’t forget that stress can distort the ability to think and code clearly. To get a fair assessment of their skills, you could let candidates choose between doing a coding test in your offices or remotely, as Slack does.

In pursuit of promoting fair testing, Slack introduced the possibility of doing coding tests from home.

However, when they noticed that not all candidates worked in conditions that were equally conducive to writing good code, they started offering the option to do the assignment in the office.

All in all, sample coding tests are a reliable way to gain insight into the candidate’s coding skills, as long as you construct them in a way that removes distractions and motivates candidates to focus on coding.

Organize a live coding session

As opposed to sample coding tests that allow the candidates to spend days polishing their code to perfection, live coding sessions present you with an opportunity to witness the thought process behind the code in real time.

If you decide on live coding sessions to evaluate developer skills, be careful not to turn the session into a dreaded whiteboard interview.

In 2017, a number of successful, experienced programmers turned to Twitter to express their dissatisfaction with broken job interview processes.

Even David Heinemeier Hansson, the founder of the popular Ruby on Rails development framework, admitted he wouldn’t pass a simple whiteboard interview.

Source: Twitter

Hansson, like many other developers, relies on the internet when coding. You should take that into consideration when organizing your live coding session.

In other words, you can only get an accurate representation of coding skills if you allow the candidate to work with the tools and resources they would normally use.

Such an approach will help you see how a candidate thinks and solves problems on the spot, with the added benefit of greater time efficiency over sample coding tests.

Another way to see how a candidate performs in a realistic scenario is pair programming.

As we wrote earlier, developers usually work in teams. There’s no better way to determine if somebody is a team player than putting them in a collaborative environment.

According to Steff Kelsey, VP of Appcues and member of the Forbes Technology Council, pair programming sessions are a pragmatic method for checking if an engineer is a good fit.

“Programming with one or more engineers from your team very closely represents doing the job. You have the opportunity to evaluate how they write, read, test and debug code, as well as how comfortable they are using the tools.”

However, you shouldn’t pair two candidates together. Instead, as Kelsey advises, pair a candidate with a developer from your company.

Whether you choose solitary or pair live coding sessions, you’ll be able to assess a candidate’s thought process when solving problems and see what questions they ask about software.

A session that’s fairly set up will also show you how a candidate uses the tools and resources available to write the best code they can.

Conduct a technical interview

Rather than focusing on code only, technical interviews help you assess how a candidate processes information and communicates ideas.

If you recall what Tracy Phillips said about the flaws of coding tests, you’ll notice that many candidates complain about not getting feedback on their code.

Technical interviews are usually conducted after coding tests, making them an excellent opportunity to follow up on code tests and ask candidates to explain the programming choices they’ve made.

That way, you show genuine interest in a candidate’s thought process, while the candidate gets the chance to explain their code.

A different approach to technical interviews is to discuss theoretical programming-related questions with candidates.

However, you should always select questions that are relevant for the candidate’s prospective position, as irrelevant questions and exercises are the top elements developers dislike about the recruitment process.

Source: Shake

At this stage of the recruitment process, it’s best if your technical roles take over the reins of the interview. You should ask your CTO, experienced developers, or team leads to work with the hiring manager here.

The technical questions you ask depend on the role.

Indeed has compiled a list of common technical interview questions, and here are our suggestions as to what you can ask an iOS developer.

  • What are the advantages and disadvantages of using SwiftUI?
  • What are provisioning profiles?
  • When is it appropriate to use an implicitly unwrapped optional?

Since some claim that in-person technical interviews put introverts at a disadvantage, you may consider starting with technical questions that sound less intimidating, such as What was the first programming language you worked with?

Besides giving you a closer look into a candidate’s programming knowledge, technical interviews can also help you see how they react to new information.

If you ask them about the technology they’re not too familiar with, you can observe their reactions.

Do they ask for clarification, or do they claim there’s no reason for them to know about it?

All these are valuable clues indicative of how a developer would fit in with your team.

Test them for their soft skills

Usually left for the last portion of the interviewing process, the soft skills assessment is vital for the overall evaluation of a developer.

These skills determine how easy a developer is to work with and if they fit your team and company culture.

The general soft skills lists usually include qualities such as:

  • Communication
  • Positive attitude
  • Conflict resolution
  • Adaptability
  • Teamwork

The world of software development, however, has more specific requirements.

For instance, each developer has to be able to organize their work; there’s no teamwork without this prerequisite. 

Mark Runyon, a programmer turned IT consultant, has firsthand experience of what it means to hire a proficient programmer with inadequate soft skills regarding prioritizing and organization. 

Here’s a recap of his story.

Runyon worked with a developer who was able to identify problems, track bugs, and come up with quick fixes.

Unfortunately, quick fixes were the peak of his attempts to solve the problem; he would fix the immediate problem and ignore the underlying issue.

Mending the same problem over and over again eventually wore the developer down. Finally, he resigned and left the bugs to other developers to deal with.

This cautionary tale teaches us that the fact that a developer has the necessary coding skills doesn’t mean that he or she applies them properly.

To identify and avoid can kickers, Runyan suggests asking candidates the following question:

“A bug crops up in a mission-critical application. Describe how you would diagnose and resolve the issue.”

Questions formed like the one above will help you evaluate a candidate’s soft skills.

Asking the candidate if they are a team player or a critical thinker won’t get you far. Instead, it would be better to ask about their previous experiences or go with problem-solving questions to see soft skills in action.

You can use the table below as a guideline for assessing the soft skills vital for developers.

Soft skillInterview question
Effective communicationWas there ever a time when you delivered a product that didn’t match the client’s expectations? What was the source of the misunderstanding?
TeamworkHow do you proceed if your peer does code documentation one way and you think there’s a better option?
Willingness to learnHow do you keep up with developments in technology outside of work? Do you listen to tech podcasts or have side projects?
Deadline estimatingHave you ever miscalculated the time needed for the project? How did you solve the issue?

So, when evaluating a candidate, try to look beyond their code. The way they work or interact with others can be a crucial factor determining the success of the team, and ultimately, the product.

Conclusion

The way to a great product starts with a great team. We know that finding a skilled developer may be difficult, but it’s not impossible.

While there’s no universally valid evaluating method that fits all agencies in their quest for hiring the best talent, there are several tried-and-true assessment strategies you might find helpful.

Whether you choose to conduct live or at-home coding tests, done individually or in pairs, don’t forget that soft skills are just as essential.

About Shake

Shake is a bug and crash reporting tool for mobile apps. It was founded in 2019 with the mission to help app developers spend less time on debugging and manual overhead — and growing daily since thanks to a small and dedicated team of geeks based in the EU.

Meet your favorite bug and crash reporting tool.

Add to app in minutes

Doesn’t affect app speed

GDPR & CCPA compliant