The Problem With Today’s Tech Hiring Processes—And How You Can Do Better for Your Business

Top technical talent is the cornerstone of innovation, efficiency, and productivity – and ultimately, financial performance. But most organizations are struggling to hire good developers and it’s becoming a major blocker for growth. Is your talent acquisition function taking the right approach to overcome these hurdles? Quite possibly not. 

As concerns about cheating increase, skills shortages deepen, and turnover escalates, leaders must evaluate whether they’re truly equipped to battle these challenges.

The key question is, are the same old hiring processes suitable for the modern world? We think the answer is a resounding ‘no’. 

We think many organizations are sleepwalking into problems they’ll struggle to backtrack from. Even if everything seems fine today (and you’re lucky, if that’s you). It’s like getting tangled in a bramble bush: the harder you fight, the more trouble you’re in.

Let’s talk about that.

An invisible challenge in technical hiring 

Most organizations struggle with the same problems around hiring technical talent, especially in the context of severe skills shortages. The US Department of Labor estimates that the global shortage of software engineers will reach 85.2 million by 2030, for instance. 

The symptoms are near-universal: 

• Lack of quality applications
• High candidate attrition
• Declined offers
• Unfilled roles
• High churn

To address these issues, teams often take the same approach. 

• How do we attract more, better candidates so we can hire them? That’s logical – and an important conversation. If you’re not attracting great engineers at the top of your funnel, you won’t hire great engineers at the bottom.

• And how do we improve efficiency, so we don’t lose good people to speedier competitors? That too is logical. The average global time-to-hire across all roles is 42 days – leaping to 62 days within Engineering. Hitting – or, better, improving on – benchmarks keeps you competitive. 

These are worthy focuses. But they miss one of the biggest causes of those uncomfortable hiring symptoms, because they make one fatal assumption: that you’re good at reliably identifying what “great” talent looks like. 

That is, they assume you’re struggling to hire because there aren’t enough great people and because competition is high. Ergo, if only you could attract more great talent and move them through an efficient recruitment process, you’d make more great hires.

The problem is, many organizations don’t realize they just aren’t good at evaluating talent. The technical recruitment process isn’t set-up to facilitate good decision-making. So even when you improve your inflow, you still struggle with many of the same symptoms. 

Here’s what’s happening. 

Recruitment vs. reality: the great disconnect 

A harsh truth: most organizations’ evaluation processes for technical talent aren’t fit-for-purpose. 

They don’t reliably identify the best people – so you either miss great hires or, worse, hire poor ones. With all the costs and consequences that entails. And they usually derail the candidate experience at the same time, exacerbating existing issues.

Think about what recruitment is meant to evaluate. Who’ll thrive in this job? Who’ll add the most value, for longest? To empower those decisions, technical evaluation processes must align closely to the actual job you’re hiring for. That is, they must be realistic. 

If you’re hiring for a sales rep for your contact center, for example, you need to evaluate how they function in a contact center environment tackling the same sorts of scenarios they’ll handle day-to-day.   

That might sound obvious, but when it comes to technical hiring that’s not what’s happening in most organizations. Frequently, technical evaluation processes bear little resemblance to the job at all. Look.  

Screening

Your recruitment team exists because it would be inefficient and unproductive for technical managers to handle first-stage screening. But recruiters are specialists at recruitment – not software engineering. 

Even the best technical recruiters can struggle with deep technical nuance, especially for niche or senior roles. Especially given that managers often fail to give enough role information to empower effective screening. 

(Source)

And that’s before you consider AI, which has totally blown-up recruitment over the past 18-months. Arctic Shores report that 58% of candidates use AI to boost their chances of securing a role, for example.

Now, recruiters are swamped by 10x the application volume and it’s harder than ever to tell resumes apart. Plus the whole process takes ages, which doesn’t help time-to-hire woes.

The result is an inefficient, ineffective screening process that doesn’t consistently progress the best applicants through to interview. Little wonder that 25% of technical hiring managers say a shortage of skilled talent is their primary obstacle to recruitment. 

Interviews

(Source)

Sure, recruiters might’ve missed some great candidates at screening – but surely your managers are good at spotting the right devs for their teams?

Unfortunately not. For many organizations, coding interviews are broken. Often they’re:

• Generic, relying on stale questions candidates have seen time and again
• Unrelated to the job or company, telling candidates nothing valuable
• Language-specific, forcing candidates into arbitrary boxes
• Unfamiliar, using platforms and hardware candidates don’t normally use
• Time-consuming take-homes that candidates don’t like
• Heavy-handed anti-cheat measures, assuaging concerns about cheating, but stopping candidates using everyday tools 
• Unreasonable and disrespectful, asking too much in too little time 

Coding interviews like this do a terrible job at evaluating whether candidates will thrive on-the-job. And they do a terrible job at helping candidates evaluate the role and company too, so poor-fit applicants can’t self-select out. And they drive away some of your best applicants, who simply won’t waste time on processes like that.

The upshot? Same as screening. An ineffective, inefficient process you can’t trust to identify and hire the best people. 

In both cases, candidate evaluation isn’t realistic. Instead of evaluating how candidates will perform on-the-job, they evaluate candidates’ ability to:

• Write CVs (or use ChatGPT)
• Memorize past questions
• Recall snippets they’d normally Google and build on
• Make time for over-long processes
• Code in languages they don’t usually use
• Churn out code as fast as possible

If your job description doesn’t look like that, it begs the question why you’re interviewing for those skills…

So why does this matter? And does it matter in the first place, if you’re not currently struggling to hire and your technical teams are mostly performing OK?

The answer’s lots, and yes. 

Why your organization should care (even if everything seems fine)

If, like 95% of organizations told Hays last year, you’re struggling to hire technical talent then it’s obvious why this stuff matters. 

You need to hire more, better developers, but there’s this big, meaty, often overlooked problem sitting right at the heart of your technical recruitment process. 

A big, meaty, often overlooked problem that:

• Increases time-to-hire which
• damages the candidate experience which
• skyrockets candidate attrition which
• makes hiring harder.

and 

• Bungles your candidate experience which
• damages your employer brand which
• hurts candidate attraction which
• makes hiring harder.

and

• Hinders smart decision-making which
• increases the risk of poor hires which
• decreases productivity and increases turnover which
• makes hiring harder.

… all of which translates into increased recruitment costs and lower productive output. The opposite of the successful business equation.  

And the issue is, it mightn’t be immediately obvious without crunching the numbers.

Back-of-a-napkin calculations: the ROI of improving candidate evaluation Say you’re hiring 50 software engineers on $100,000 salary each. (According to Indeed, the average annual salary for a software engineer in the US in 2024 was $105,212 plus a cash bonus of $5000. But let’s make the math easier). Then say it costs you around a third of annual salary to hire them – $30,000. Costs vary wildly depending on factors like location, type of team, cooperation model, seniority, project complexity, and experience level. And who you listen to. (Here’s an interesting breakdown). Take this as a finger-in-the-air example or use your own data to work through the example. If recruitment has an 100% success rate, you’re already looking at costs of ($100,000 x 5) + ($30,000 x 50) = $6,500,000. That’s $6,500,000 of productive value those engineers need to deliver before you break even.  There’s not much good benchmark data around timeframes for this, but an old Harvard Business School survey says business leaders expect new hires to contribute more value than hiring them cost within six months. Let’s take that as a loose sketch. So if you’re hiring 50 software engineers, you ideally hope to see $6,500,000 of value within six months. But then let’s imagine you’re experiencing the hiring problems we’ve been talking about. The Bureau of Labor Statistics reports that software developers have a (staggering!) average turnover rate of 57.3% – 29% of which were involuntary, while 25% were voluntary. So let’s assume you’re losing 28 of your 50 engineers. Now, you’re stuck re-recruiting for those 28 developers. So that’s another $30,000 x 28 = $840,000. But you’ve also got the wider costs to consider. Code that’s caused rework or damage. Declining morale. Wasted onboarding and training. Project delays. Longer times-to-market. Missed innovation opportunities. Unhappy customers. Reputation damage.  Typical benchmarks put the cost of a bad hire at three times annual salary: so $300,000 per engineer. 28 x $300,000 = $8,400,000. Plus the $840,000. So now, to hire 50 engineers you’ve paid: ($100,000 x 50) + ($30,000 x 50) = $6,500,000PLUS($300,000 x 28) + ($30,000 x 28) = $9,240, 000 … which equals $15,740,000.  So now – assuming no further attrition – you’ve got 50 engineers. But now they need to deliver $15,740,000’s worth of value to break even on hiring: 142% more. That’s an enormous amount of pressure on new hires. And it pushes up your time-to-break-even to 14.5 months. That’s an enormous drag on the business. A huge constraint on what you can achieve, how quickly.  Improving candidate evaluation isn’t a silver bullet, of course. An 100% hiring success rate is an impossible dream. But there’s a clear value case here.  If you even improved quality-of-hire by a third, you’d save a vast amount on hiring, relieve huge pressure from your technical teams, and achieve breakeven much earlier – so you can deliver what your organization stands for.  Plug in some of your own numbers, to get a better idea for your organization: How many technical hires are you forecasting next year? What’s your average cost to hire?  What’s your average time-to-productivity?  What’s your turnover rate?  This should help build a clearer picture of how much improving candidate evaluation could save you over the long-term.

Unblock growth by dismantling unrealistic hiring processes

In short: ineffective technical recruitment is one of the biggest blockers to business growth. 

Deloitte talk about an “endless game of catch-up” as organizations “resort to shortcuts for software development and commit their tech talent to maintaining legacy systems at the cost of driving growth”. It’s a “vicious cycle” that makes it “increasingly difficult for organizations to deliver on their long-term commitments to stakeholders”.

These challenges have no single answer. Leaders must take a bird’s eye view over the end-to-end technical recruitment process, exploring how they attract, engage, evaluate, and hire top talent.  

But right now, many teams are glossing over the “evaluate” part of that process – and there’s enormous opportunity here to create change.

👋 Want to improve your skills evaluation process? We can help.