Why Companies REALLY Use LeetCode 🤨

Photo by kerry rawlinson on Unsplash

Senior developers are extremely valuable and provide multiple pathways to solutions. This means that they can demonstrate and deliver value to organizations, solve problems and make things happen. 

Why are they being forced to jump through whiteboard circus tricks just to prove they can code?

We put them into an interview situation where a fresh-faced engineer demands they invert a binary tree on a whiteboard with a timer counting down. Nobody has worked on these problems since college, and they are typically irrelevant to the role. It might be seen as borderline offensive to ask this of a senior developer, but it’s also rather pointless to ask the same of a mid or junior developer.

So why does this happen? It’s not just about testing skill. I’ll tell you the real answer. It’s about minimizing costs.

The Hiring Hack

Codality, LeetCode, HackerRank and competitive programming platforms have changed the perception of software engineers. It doesn’t matter how many years of experience a developer might have when you have a platform that sets the bar for software engineering talent.

The truth is that this is a hack for software companies. They favor recent graduates and younger engineers, who are easily identifiable because of their fresh academic training in algorithms. 

The truth is that experience is expensive and does not align with big tech’s priorities. Software engineers with sufficient experience know when to push back on bad practices or when a task is unreasonably scoped. Younger hires, by contrast, are eager to prove themselves and tend to accept the grind without question, at least until they burn out.

Sure, we can say this is unconscious ageism. The companies justify it as prioritizing skill and claiming that experience doesn’t lift the bar. Even if that were true, we would need to ensure that the skills being tested were relevant to the actual work of a software developer, wouldn’t we?

Cost is Everything

Here’s the unvarnished truth. Enterprise application developers rarely need to implement the algorithms tested in coding interviews. This part of the interview process is almost completely irrelevant to the job or potential performance in it. That is because these tests were never designed to get the best engineers; they’re designed to find the cheapest acceptable engineers.

When you build your hiring pipeline around algorithmic tests, you systematically exclude developers who have prioritized solving real-world problems over memorizing textbook solutions. The result? A workforce that is cheaper, more malleable, and less likely to challenge harmful practices like unpaid overtime or burnout-inducing crunch periods. You don’t have to worry about engineers with children (who get sick, and are a distraction from the work), they don’t have time to study “Cracking the coding interview. You don’t have to worry about the problems older developers bring, as they won’t accept this method of measurement and will self-select out of the hiring process. Neurodiverse candidates will have lower scores due to the arbitrary, high-pressure format.

You’re instead left with engineers who are younger, malleable enough to go through your 7-step hiring process and crucially cheaper. And let’s not even start on the irony of claiming fairness when your hiring process is inherently designed to favor a narrow demographic.

HR are happy because the process is “non-discriminatory” and meets everyone’s goals. Some software engineers also support the process because they had to go through it too and want to inflict the same pain on the next generation.

Losses and Losers

When we devalue experience, we devalue culture too. Companies might save money in the short-term, but they create organizations that lack wisdom. Experienced developers bring the context that competitive programmers seldom can, and might even bring empathy and good working practices along too (and it is these qualities that a good recruitment process should be optimized for).

Here is a wish list of things that experienced coders can bring:

:tick: Code Maintainability

A seasoned coder knows that simple, readable code is better than clever tricks that only they understand.

:tick: Team Dynamics

They’ve worked in environments where egos sink projects, and they know how to avoid repeating those mistakes.

:tick: Technical Debt

Instead of hacking together a solution, they think about the long-term implications of their choices.

But these aren’t qualities you can measure in a 45-minute LeetCode test. They’re ignored and it’s the tech team that has to pick up the pieces as competitive programmers are integrated into the team at the expense of rounded more experienced software engineers.

Big Tech

Smaller companies mimic FAANG hiring practices because they assume what works for Google must work for them. Instead of critically examining whether algorithm-heavy interviews are relevant to their own needs, they blindly follow the trend.

This trickle-down effect reinforces a cycle of short-term thinking and devalues skills that take years to cultivate. Companies complain about the lack of senior talent in the market while simultaneously creating a hiring process that filters out anyone who might fill that gap.

Breaking the Cycle

It’s easy to criticize, and fun too. Yet that’s not what I’m going to do here.

I’m actually going to go one step further. Here are some suggestions as to how we might fix this vicious cycle.

Reassess Interview Priorities

Tailor technical challenges to the actual job. If your role is application development, test for that. Testing esoteric algorithms might work for some roles, but it should be a choice to test these rather than the default position.

Consider Candidate Contexts

Offer alternative assessments for candidates with extensive experience or non-traditional backgrounds.

Invest in Training

Instead of filtering for perfection, hire for potential and provide the tools to succeed. That also might help some companies find suitable employees when they can’t quite attract the top-tier talent they would like to.

Call Out the Copycats

Companies need to stop emulating hiring processes that don’t fit their goals or team structure. Simply copying one of the failing FAANG companies isn’t just a bad look it’s a recipe for a bad fit set of recruitment practices.

Conclusion

The rise of LeetCode-style interviews isn’t about merit or hiring the staff that fit an organization at all. In fact, it’s about money. By focusing on algorithmic puzzles, companies justify hiring cheaper, less experienced workers under the guise of fairness. Meanwhile, the industry loses out on the expertise needed to navigate its increasingly complex landscape.

If you’re an older developer or someone who prioritizes practical skills over competitive coding, you’re not the problem. The system is. And it’s time for it to change. Which one of you is going to do it?