Is the technical interview broken? Turns out, it depends on who you ask.
Search “are coding interviews broken” on YouTube and you’ll find countless videos by developers and hiring managers with passionate opinions on the subject.
Calling the topic controversial is an understatement. But it’s also a critical conversation for the tech industry to have.
The processes companies use to hire developers have huge implications for their ability to build effective teams and attract great talent. And the careers of developers rely on the opportunity to demonstrate their skills in a fair, effective interview process.
With so much at stake, we think it’s time to put the question to rest for good. Is the technical interview actually broken?
What Is a Technical Interview, Anyway?
Before starting a debate about whether the technical interview is broken, it’s worth defining what a technical interview actually is.
The technical interview, sometimes called the coding interview, is the process of evaluating candidates through interviews that place an emphasis on technical skills. During the process, hiring managers and recruiters rely on individual assignments, often referred to as coding questions or challenges, to score a candidate’s proficiency in key skills.
What makes a technical interview distinct from a screening assessment is the dynamic conversation between interviewer and interviewee that takes place alongside the actual coding. As candidates work through questions and write code, they engage in a dialogue with interviewers about their problem-solving approach and try to find the most optimal solution.
These interviews gauge a candidate’s problem-solving skills and technical proficiency in various programming languages and frameworks. They can also measure the candidate’s ability to navigate a complete application environment, design systems, translate log messages, and interchangeably use the command-line, IDE, and browser to interact with the environment. And they also give a glimpse into soft skills, like the candidate’s collaboration or communication style.
The technical interview can take many styles and formats, including:
- Data structures
- System design
- Language-specific tests
- Problem solving
- Multiple choice questions
- Take-home challenges
So — Is the Technical Interview Actually Broken?
It’s tempting to answer this question with a strong yes or no answer. However, the situation is a bit more complex.
On a micro level, there are as many different approaches to technical interviews as there are companies hiring technical talent. Even individual teams within a single company are likely to conduct interviews differently. That means that the overall quality of the technical interview, in practice, exists on a spectrum. There are plenty of teams with consistent, standardized, and skills-based interview processes that are not broken.
But if you take a step back and assess the big picture, you’d see that there are large, underlying problems with the standard technical interview. Across the tech industry, many companies have lagged behind in modernizing their technical interviews to keep up with the current best practices and technical solutions.
Think about it: If the current approach to technical interviewing was perfect, would you be reading this blog? Would we be writing this blog? Would developers be engaging in passionate debates about whether the process is broken or not broken (and garnering millions of views in the process)? The fact that the tech industry is asking these questions in the first place is indicative of an underlying problem.
The technical interview is in a state of transition. Whether the interview is broken or not depends on the company, the team, or even the individual administering it. But the technical interview itself is an evolving concept experiencing growing pains as it tries to adapt to the modern tech industry.
How Can We Improve the Technical Interview?
The technical interview has been around for decades. In that time, it’s gone through multiple transformations. Each iteration was designed to fulfill the needs of the tech industry at the time. But when the technical interview grew stagnant, vocal developers and innovative employers built new processes that provided better hires, created a stronger candidate experience, and emphasized more relevant skills. To “fix” the technical interview and build its next iteration, we’ll need to go through the same process again.
So, what is the next iteration of the technical interview? The answer has been in front of us this whole time. The technical interview of the future will be a candidate-centered hiring experience built around real-world developer skills.
The good news is that this process is very much underway. Some companies are already reorienting their hiring processes around the application of the skills through interview experiences based on real-world job scenarios. While this will be a long-term project, there are four changes that employers can make today to improve their iteration of the technical interview.
1. Relevance of Questions
One often cited complaint about coding interviews is that they’re not relevant to the job the candidate is interviewing for. And there may be some truth to that.
While algorithm challenges about binary trees are grounded in technical skills, few developers and engineers need to memorize the application of such skills in their everyday work. This can lead to developers memorizing and then forgetting algorithmic concepts such as greedy algorithms, Dikjstra, or dynamic programming — all to land a job that will never require them to use those algorithms without documentation or resources. This is particularly true for mid- to senior-level developers, who are years removed from the academic setting where algorithms are taught.
One way to solve this challenge is to use problem-solving questions that are based on the skills required in the role at hand. And this shift doesn’t need to be overly complicated. Even an exercise as simple as debugging code will give candidates the opportunity to complete tasks that they’d actually work on every day.
2. Time Limits and Duration
Setting time limits for coding interviews is like walking a tight-rope. If the interview is too short, the candidate won’t have enough time to answer the question. This can leave them feeling stressed about their performance, or even that they weren’t fairly evaluated.
But if the interview is too long, it becomes a burden on both the candidate’s and the interviewer’s time and begins to feel like work. Interview duration is a balancing act that requires careful consideration.
As a rule of thumb, coding interviews generally last 30-60 minutes. However, the ideal duration for an interview will vary depending on the company, the role, the skills being assessed — or even the individual candidate.
Identifying the sweet-spot for interview length requires a data-driven approach. For employers, understanding the appropriate time limit for solving a particular type of question – like an intermediate-level SQL problem – will require either trial-and-error or partnering with a technical interview platform that already has that data available.
3. Using Modern Interview Tech
Natural language processing. Artificial intelligence. Web3. The metaverse. Developers, engineers, and the companies that employ them are working at the vanguard of technological innovation. But many companies still conduct technical interviews with dated, legacy tools.
Anecdotally, we’ve even found that a surprisingly larger number of companies still administer – or only just recently switched away from – coding interviews using primarily pen and paper. And the industry standard is still for candidates to write their code in digital word processors while logged into a video conferencing platform.
If a company is hiring developers to work on innovative tech, the tools they use to interview candidates should demonstrate a commitment to that level of technical innovation. Evidently, technical teams in every industry agree. Over 25% of Fortune 100 companies are turning to technical interview platforms to level-up their interview tech and create a better hiring experience for developers.
4. Collaborative IDEs
A collaborative integrated development environment (IDE) is a tool that allows developers to write, edit, and debug code in their web browser. Developers use collaborative IDEs because they enable multiple people to work on the same code at the same time.
These tools have quickly become the gold standard for technical interviews because they allow developers and interviewers to seamlessly collaborate on interview questions in real time.
So, is the technical interview broken? We think it’s going through a period of growth and iteration that’s led to a few growing pains for interviewers and interviewees alike. There are a number of companies whose interview processes aren’t broken and can serve as a model of what the technical interview can become.
One thing is certain: the next iteration of the tech interview won’t be the last one. In the not-so-distant future, technical teams will once again rebuild their hiring processes with new tools and interview formats that will make algorithm challenges look as obscure as the trivia questions that preceded them.
This writer’s prediction? It’s possible that the future of the technical interview will be that there are no technical interviews. Immutable, verifiable coding projects on the blockchain could replace resumes and coding challenges, acting as all of the proof a hiring team needs of a developer’s skill. We’re not living in that future yet, but it’s exciting to think about the possible advancements to come.