If you look at discussion forums for people in the CS industry —
like /r/cscareequestions or even just Hacker News —
you’ll find lots of talk about the so called Big Four companies.

This is mostly in the context of applying to them, or going through their interview process.
Which of the large software corporations are discussed here tends to fluctuate a little bit,
but both Google and Microsoft are invariably included, with Facebook popping up more often than not.

Because of their privileged positions as very desirable places to work, these companies tend to be taken as models
for others to mimic1. Probably the most apparent and direct outcome is the increasing prevalence of
“Google-style” interviews, which are now utilized by countless software shops around the world.

Whiteboard coding is how they are often called. It is a subject of an intense debate, whether or not they “work”,
and adequately assess the engineering aptitude of candidates. If some
high profile anecdotes are of any indication, the most common complaint
is that they fail to recognize competence by ignoring previous professional work, open source contributions,
conference talks, and so on.

Instead, the whiteboard interview requires demand showing a “pure” problem solving ability
within a relatively short time window, all without some broader context or even the usual tools of the trade:
laptop, editor, and a search engine.

As a Googler who had gone through this process and has now conducted a few of those interviews himself,
I find those complaints mostly valid albeit misdirected.

The problem isn’t really that Google interviews like it does.

What’s really the issue is other companies implementing the same process, and not realizing it cannot possibly work for them.

Somewhat special

It is important to understand that Google’s stance on interviewing is influenced by some unique circumstances:

very high and steady influx of potential candidates

comparatively long tenure of the average engineer and the general focus on employee retention

huge and mostly proprietary software stack working at a scale that almost no others do

From this perspective, it makes sense to utilize cautious hiring strategies that may result in a high ratio
of false negatives2. When rejections are cheap but the new hires are supposed to be here for the long run —
partially because of the long ramp-up time necessary to become productive — it can be costly to give candidates
the benefit of the doubt.

The last point also explains why proficiency with specific technologies is less useful than
general flexibility grounded in strong fundamentals. To put it shortly, Google prefers you know
CS rather than CSS.

Finally, whiteboard coding is just one input to the evaluation process, but it tends to be the most trustworthy one.
Besides programming aptitude, the ideal candidate would show a proven track record of technical leadership while
tackling complex problems that span a broad scope.
Unfortunately, those qualities are difficult to convey efficiently and reliably through the usual industry channels:
a resume, references from previous jobs, GitHub profile, etc.

Different conditions

Given the above reasoning as to why “Google-style” interviews seem to work well for Google, I hope it’s evident why
they are likely a poor choice for companies that don’t share the same characteristics as the Big 4.

For one, it is highly unusual for a software shop in today’s market to command a sizeable pool for qualified candidates.
Software engineering vacancies often go unfilled for weeks and months, even if the company isn’t exactly looking
for “rockstars”, “ninjas”, “gunslingers”, or whatever the silly term du jour is. Those who meet the requirements
usually have their pick at many different offers, too.

The reality for many companies (especially startups) is also one where they are unable or unwilling to invest much
in the retention of their employees. Because the employment relationship in this industry tends to be quite volatile
(which isn’t necessarily a bad thing), it often makes sense for companies to look for a near-immediate payoff
when hiring.

We owe it to the prevalent open source technologies that this isn’t entirely unreasonable. If your software stack
is composed entirely of components that are available in the open, you can probably find engineers who are familiar
with most of them. They can be productive members of your team almost literally from day one!

Right tool for the job

The most important observation is that every company is different, and following the One True Best Practice™ will likely
prevent you from utilizing the best qualities of your work place. Smaller shops, for example, could take a more personalized
approach to hiring: let candidates actually sit with engineers, solve real-life problems, and have deep technical conversations.

Of course, you may still find whiteboard coding valuable in its own right. Indeed, a simple test for at least
the basic programming skill appears to be a necessary sanity check.

But a full suite of difficult technical interviews with tough algorithmic problems that last a better part of the day?
Most likely not.

Some seem to have succeeded to such an extent that you may occasionally hear about “Big N”.
This often includes some currently large and/or successful but still “hip” startups.
IT is such a fashion industry sometimes… ↩

Though on the flip side, it exacerbates the impostor syndrome
among people who do get hired, as their success could easily be construed as mostly luck. ↩