Tell us what *you* think of our resources and what you’d like to see here in 2023. FILL OUT OUR SURVEY

How to screen and interview software engineers at speed and scale

According to GoRemotely, the average number of applicants per job is 250. However, for software engineering roles, this number goes down to just 21 – that's almost 12 times less than the average.

So you have to be extra diligent when engaging with software engineering candidates as they are notoriously difficult to source.

Assuming you’re able to attract a decent number of candidates per role, you still have to balance this quantity with identifying and shortlisting the most talented engineers. Otherwise, you’re likely sacrificing an average of $30,000 (not including compensation) for each bad engineering hire.

In this article, we’ll talk about screening and interviewing the software engineering candidates that you do get – quickly and at scale. By the end of it, you’ll be in a better position to build or improve your technical hiring process. This means:

  • Clarity – everyone is aligned on the way you screen and hire engineers.
  • Speed – faster time to hire so you avoid losing strong applicants during the hiring journey.
  • Retention – hiring the right person in the first place can improve employee retention.

To achieve these goals, we’re going to suggest a standard hiring process for you to use and tweak for your organization. We’re also going to present the dos and don’ts for screening and interviewing developers based on CodeInterview’s first-hand expertise based on more than 100,000 engineering interviews per year.

But first, why should you have a separate hiring journey just for engineers?

What’s different about hiring tech talent?

Hiring technical talent is, in many ways, similar to hiring other types of professionals.

You define a role, advertise the job post, evaluate candidates, negotiate an offer and onboard the new employee.

However, there are details in this process that need special attention.

For example, the sourcing channels you use may be developer-focused or you may have to rely on headhunting more than usual due to high demand for talent.

When it comes to screening and interviewing, you will need to take into account criteria such as the specific technologies the role requires. And then, test for them.

You will also need different evaluation tools beyond questionnaires and meetings.

With that in mind, let’s take a detailed look at the key changes you need to introduce when designing and improving your technical hiring process.

Source and attract more candidates

Workable helps you build and promote your brand where your next candidates are. You’re always top of mind, whether they’re actively looking or not.

Start sourcing

1. Prioritize skills over experience and education

Few disciplines move as quickly as software engineering.

New technologies and frameworks emerge all the time and candidates that become complacent may fall behind, despite having many years of experience.

Moreover, the best developers are often self-taught tinkerers with little or no formal education in computer science.

So while a candidate’s professional and academic background is important, you should pay more attention to their skills and thought process demonstrated throughout the hiring journey.

2. Rely on coding tests and portfolios more than CVs

Don’t get me wrong – your screening process is still likely to start with a CV.

However, this is more of a tripwire to make sure irrelevant candidates are filtered out. For example, if you’re hiring for a Senior Ruby on Rails engineer, you should not waste time on candidates that are unfamiliar with this technology.

So in contrast to most other roles, the CV will not be an anchor point for you during further stages like an interview. Rather, it’s going to be projects the candidate has worked on and how they approached them.

Nowadays, you will typically have access to the candidate’s GitHub as a reference to previous projects. You can also send automated coding tests and discuss these during an initial interview.

While some candidates may be better at selling themselves on paper, hard coding skills can’t be faked or exaggerated. For these reasons, you should prioritize objective evaluation methods rather than resumes.

3. Send take-home projects instead of competency interviews

Take-home projects are typically longer (2-4 hour) assignments that dive deeper into a specific skill or technology required for the role.

These assignments are often paid and serve to narrow down your shortlist to just two or three candidates who make it to the final cut. As such, they are well suited as a follow-up to the initial interview.

While you can still have a competency interview, the take-home project can serve as the anchor point for this, discussing their thought process during a solution presentation.

4. Implement a solution presentation

While coding tests and take-home projects are relatively objective measurements of skill, some candidates may be able to bypass the rules by re-taking the test multiple times or getting help from a friend.

This is where a solution presentation is handy – think of it as a chance for the candidate to justify their approach. It’s also a good way to evaluate the candidate’s communication skills.

5. Hold virtual or in-person whiteboard interviews

For senior-level positions that require extensive knowledge of software architecture and design, you will often need to conduct a classic whiteboard interview.

6. Equip yourself with new tools

Hiring developers requires tools beyond online conferencing and email – particularly when hiring tech workers remotely. For example, you’ll need a coding interview tool, technical assessment software and a virtual whiteboard.

7. Adopt a new perspective for technical hires

As you can see, hiring technical talent requires changes to your hiring process and tools.

But there’s one more thing to keep in mind – the competitive landscape, especially if you’re not on the tech workers’ A-list. Because engineers are in such high demand, you need to adopt a perspective around speed and candidate experience to avoid losing candidates to competitors.

In addition, good developers are hard to find so make sure you optimize your sourcing channels and make the most of the applications that you do get from your efforts.

Standard technical hiring process to use

To present the best practices when screening and interviewing developers, we’ll suggest a sample framework you can use directly or tweak for your organization. Here’s the process:

1. Pre-screen

CV upload and a brief questionnaire to filter out candidates that don’t meet your minimum criteria. Your ATS should have the ability to filter applications based on self-selected skills.

Here’s the rationale: The CV and questionnaire are low barriers for getting candidates through the door. Engineers, probably more than anyone, don’t like lengthy hiring processes. When you reduce the barrier to apply, you create the initial commitment to complete the application.

At this stage, it’s important to develop a simple checklist to help you filter candidates faster. For example:

  • Years of experience
  • Programming languages & frameworks
  • Any big achievements
  • Salary expectations

2. Screen

Send an automated coding test to all candidates so you can objectively rank them based on skills and speed. Review the top candidates’ GitHub accounts to get a better understanding of their experience. Optional: request a short video introduction, especially for engineering management roles.

Note: Coding tests are prone to cheating (despite plagiarism detection). So don’t skip step 3 below:

3. Initial coding interview

Here’s what you should do here: prepare! Candidates are not the only ones that get assessed at this stage. You will also represent your company and creating a bad impression by not being organized or having the right questions prepared in advance can ruin the experience and compromise your hiring.

Now, on to other practical considerations:

Schedule the initial interview to talk about the candidate’s approach during the coding test as well as specific points of interest on their resume. Prepare a set of questions depending on the role so you can see the candidate code in real time.

To help you, here are some proven interview questions to ask:

  • How would you solve problem X?
  • Why did you select this specific technology/approach?
  • What kind of resources can you recommend for someone earlier in their career?

In addition to critical thought, you should notice how many clarification questions they ask (the more, the better!); are they enthusiastic when talking about a solution? Are they able to present compelling arguments?

These types of questions will typically go a longer way than theoretical questions from CS 101.

Optional: for senior roles, you can include an additional whiteboard interview.

4. Take-home project

Narrow down your candidates to the top two or three using a paid take-home project. Allow at least a week to complete so the candidate can work around their schedule.

Here are some checkpoints to help you evaluate take-home projects:

  • Does it run?
  • Can the candidate write good test cases?
  • Does the candidate clearly log changes?
  • Did the candidate use a technology/approach they know well?

5. Solution presentation

Schedule a presentation to discuss the take-home project. The idea is to get a better understanding of the candidate’s decision making and communication skills. It’s also a good idea to invite the candidate’s potential co-workers so they can meet (online or in person) before step 6 below.

6. Trial day

Invite the best candidate to work with your team for a few hours or a full day. This is the best way to see how they would fit in and gain input from their potential team. The session can be in-person or remote, depending on the role requirements. Revert to the second-best candidate if you notice any red flags during the trial.

While this may sound like a lot, it’s nothing compared to the costs of hiring a bad engineer. As long as you approach the journey with respect for their time and effort, candidates will remain engaged throughout.

Once you go through the process several times, you will streamline the steps and achieve greater speed. You can also modify the process by removing or automating certain parts so it fits your own needs.

Needless to say, junior-level hires will not have to go through as rigorous an assessment as a senior engineer or manager.

What to avoid

Now you have a starting process for hiring technical talent. But what are some things to avoid at all costs to preserve your employer brand and the candidate experience?

Little or unclear information

Overcommunication is the way to go here. There’s nothing more frustrating for a candidate than a set of unclear instructions before meeting a hiring manager that’s waiting to be impressed.

Theoretical “trick” questions

Many candidates will have years or decades of experience so introductory CS problems are likely a distant blur.

Good developers are able to find the information they need quickly and have the necessary experience and intuition for effective problem-solving. Avoid theoretical questions designed to trip candidates unless it’s crucial to the role.

Lengthy evaluation periods

Good engineers will likely get several offers when looking for a job.

This is why you need to prioritize speed and avoid lengthy hiring procedures – or risk getting outpaced by competitors.

Make sure your process is streamlined and everything is ready for new hires to begin – from standard questions to onboarding documentation and legal contracts.

Conclusion

After years of recruiting engineers and seeing how the best companies do it, this is clear:

Developers are hard to get and harder to keep.

If you want to attract the right talent and increase your chances of retaining them, I hope the advice above will prove valuable in your technical hiring process.

To summarize:

  • Create a parallel hiring process for engineers to accommodate adequate skills assessment.
  • Utilize a standard procedure that’s understood by recruiters, hiring managers, candidates and other stakeholders alike.
  • Tweak the procedure we have suggested to fit your own needs.
  • Avoid the common pitfalls when hiring engineers such as long evaluation periods and irrelevant questions.

And if there is one thing to take away from this whole article, it’s this: hiring a bad engineer is worse than not hiring at all. So make the most of your incoming applications by rigorously selecting the best and most relevant talent for your organization without compromise.

Munir Usman is the founder and CEO of CodeInterview – a technical assessment platform for software engineers. Previously, he founded and later sold development agency Pi Labs where he personally recruited 100+ software engineers to work on high-stakes projects for companies like Microsoft, P&G and Nokia.

Let's grow together

Workable helps companies of all sizes hire at scale. Start today by
requesting a demo or posting a job for free to discover how Workable
can help you find and hire great people.

Get started