How our vetting process helps us to hire best talent

Code review is a conventional tool for enhancing code quality. It’s used both in software development and recruiting. In the first case, the goal is to provide well-structured, logically organized code without bugs. Teams use this approach to produce functional digital products of high quality which meet clients’ requirements.

In recruiting, code review helps assess developers’ expertise. IT recruiters use code review as part of the extended vetting procedure that allows to unfold developer’s strengths and weaknesses and to discover the engineer’s way of thinking.

The more traditional way of developer’s expertise estimation is written code tests. A recruiter gives a candidate a task that requires writing a piece of code. Then a seasoned expert checks the result and estimates the candidate’s professional level. This approach is workable; however, it isn’t comprehensive. A candidate focuses on the functionality. Because of the lack of time, a candidate writes code roughly focusing on the vital issues, not trying to make it elegant and matching the best practices. In other words, a developer searches for a solution for “what”, while a tech recruiter is interested in “how”.

As a way of testing a developer’s logical approach to coding, recruiters use code review. The nitty-gritty of the method is an assessment of the piece of code made by another developer. A tech recruiter gives a task and asks a developer to comment on it.

Here are the code quality layers a recruiter marks off as positive signs if a developer mentions them:

• structure;

• logic;

• design;

• functionality;

• consistency;

• readability;

• technologies relevancy;

• blocks mutual compatibility;

• complexity.

As you can see, the benchmarks a recruiter estimates are far from superficial. If a developer pays attention only to syntax errors and fails to see the potential concurrency problems, it’s a red flag. The more complex analysis a candidate makes, the higher a developer’s seniority. A number of comments matters as well. On average, in a piece of code where a junior developer finds up to five issues, a middle one will find about ten issues, and the best candidates will mention up to twenty bugs (it depends on the task, of course).

To avoid misunderstanding and poor performance as a consequence, a result-oriented tech recruiter can explain the task in a more detailed way. For example, a recruiter can say that this code review differs from the assignments a developer might have gone through while studying. It’s vital to provide the right ambiance for the test, including a candidate’s favorite IDE.

Being managed correctly, code review as a vetting tool provides a multidimensional candidate’s assessment. The approach is especially fruitful for vetting the senior developers since their expertise is multi-layered, and its estimation should be complex.

Industry knowledge is crucial for a comprehensive developer skills assessment. If you’re not into the IT industry, you can evaluate a candidate, but your notion will be neither complete nor objective. The developer’s expertise is complex; the higher the seniority level, the more challenging the assessment. Developer’s specialization matters as well. The bigger the tech stack you expect an engineer to have, the more skilled a person who makes a conclusion on the candidate’s mastery should be.

Here is just a fraction of the tech skills a developer needs to have to be competitive:

• programming languages;

• software frameworks;

• databases;

• algorithms.

A set of necessary tech tools fluctuates from one specialization to another. For a back-end developer, expertise in JavaScript, Node.js, C#, .NET, .NET Core, and Go is crucial. A front-end developer should be skilled in JavaScript, TypeScript, React, Gatsby, Angular, and Vue. A mobile app developer should have the React Native, Cordova, Ionic, Flutter, and Dart knowledge under his belt. We mentioned just a part of technologies an engineer uses for handling everyday tasks. Try to get an adequate impression of the developers’ expertise without being knowledgeable in these fields – and, perhaps, you’ll meet your Waterloo.

It’s tempting to check tech expertise by using tests – automated tools for ticking the correct answers from the predefined list. Agencies use such tools, but there are a few objections. Free tools such as Programming Skills don’t leave room for creativity in assessing and showing skills. Anyone can adjust themselves to the test “methodology” and be ready to answer the expected questions; thus, the result won’t be objective. Moreover, developing isn’t about standard solutions. In practice, in many cases, there isn’t a correct answer. Instead, there are a few ways to handle the task, and some of them help optimize processes, thus, are more effective. That’s why an expert, not a machine, should manage developer’s expertise appraisal. On the other hand, some automated tools can come in handy for the rough or preliminary assessment.

To check if a candidate meets the requirements, IT recruiters use plenty of methods and tools. The most informative parts are a tech interview and code review. These steps of vetting aren’t possible without solid tech expertise.

To be fair, you can make a few moves in developer’s assessment, having zero expertise in technologies. Look through the candidate’s accounts:

• On GitHub. It’s a hosting platform for programming code that helps developers exchange their experience. All code pieces here are open-source. It means that anybody can use the content (through an open-source license) and contribute. An active profile on GitHub is a good sign. It means that a developer doesn’t limit himself by doing a job but tends to enhance his expertise and go the extra mile.

• On StackOverflow. Here, developers ask questions and give answers. The site’s visitors vote for every activity. You can find out about candidate’s participation at a glance. Scores above average is a plus.

There are other benchmarks one can use to pre-estimate a candidate to get the first impression. These are the projects a developer worked for, the tech stack an engineer dealt with, and the deliverables a professional provided. However, keep in mind that in-depth and bias-free estimation requires tech expertise.

The last thing you can assume about developers is that they need empathy or high emotional intelligence. Developers’ job is to write code; that’s what they’re paid for. Period. If you think so, you’ve never encountered an engineer with poor soft skills. An unsociable teammate who lacks verbal skills and isn’t self-sufficient is a real disaster for a team. But, when a team lead will find out about the candidate’s imperfections, it could cost a fortune to replace a developer and make up for failing the deadlines. That’s why soft skills assessment is the usual part of the candidate’s estimation. Easier said than done. Try to measure a general demeanor, stamina, or problem-solving abilities. These qualities aren’t something you can easily detect or quantify.

By the way, let’s briefly review what soft skills are. In the IT industry, the list of the most sought-after soft skills includes:

• self-assurance as a quality that helps make decisions, take responsibility, and state opinions;

• creative mindset as an ability to find innovative solutions;

• high-level emotional intelligence as an ability to screen other people’s notions and feelings, not only articulated but expressed by non-verbal signs;

• empathy as a skill of walking a mile in somebody’s shoes before making a conclusion on the person’s opinions;

• positive attitude as a source of optimism and an ability to treat threats as endeavors with great potential for development;

• sociability and a sense of being a part of a group as a ground for team cohesiveness – a state when team members work as a whole.

How a candidate goes through the screening process tells much about a potential hire’s soft skills. Vetting is rigorous, and, for some developers, it appears too exhaustive. If a professional with an impressive resume raises his brows in astonishment when you offer him a peer coding session, perhaps, he’s not as good team player as it seems from his credentials.

IT recruiters use such a simple tool for assessing soft skills as asking open questions. It’s not as simple as it may seem (to ask a good question, one should do a lot of work); however, you can ask direct questions on the topics that interest you. Consider the following drafting:

• Have you ever disagreed with your colleagues, team leads, and senior developers? How did you manage such situations?

• How do you feel while facing challenging tasks? What is your strategy for dealing with them?

• Have you ever been severely criticized for your performance? How did you react?

• Have you ever made the wrong decision? What were the consequences? What did you do to mitigate the effect?

There is no use inventing sneaky questions. Ask what you’d like to know, follow the active way of listening, and drill down into the topic when it makes sense. Consider entrusting the candidate’s soft skills assessment to professionals since they have more experience in developers screening; thus, IT recruiters will obtain more reliable information from the interview.

As an employer, you may ponder on the culture fit concept not very often. However, your team will be aware of the cultural mismatch when you hire a person whose life and work attitudes conflict with your company’s values. It’s not a big problem when you hire just one developer who is completely indifferent to your project’s mission (on the other hand, it could be a massive problem if it’s a team lead). Anyway, you will definitely notice the lack of fellow feeling if most of your teammates don’t care about common goals and priorities. The adverse effects of weak company culture include toxic relationships, lack of motivation, productivity shortage, and slowing down the business in general. On the contrary, by hiring the culture fits and strengthening the corporate culture, you get solid advantages:

• employee turnover reduction;

• engagement and motivation increase;

• productivity boost;

• high retention level.

To determine if a candidate’s vision of work aligns with the team’s values, a company should include a culture fit assessment in the hiring process. Before you ask yourself how you can check if the candidate’s priorities overlap with your company’s strategy, consider using the professional appraisal since the task isn’t as easy as it may seem. Such terms as values, interests, preferences, habits, and priorities aren’t tangible, and measuring them requires professional expertise.

IT recruiters use psychological tests and specific questions asked during an interview. The questions could be about the developer’s experience in the past, or they could be projective, i.e., modeling possible situations. Here are some examples of the versatile questions that could be used to get a picture of a candidate’s way of building relationships within a team and dealing with everyday tasks:

• Recall the situation when deadlines changed abruptly. What was your first reaction? How did you handle the deadline shift?

• Have you ever caused a failure? Are you sure it was your fault? What did you do when you found out about a problem?

• Imagine a company that is perfect for you: your career perspectives, relations with colleagues, work-life balance, mood, and mental health. Tell us about this company in detail.

• What do you expect from your senior teammates?

• What type of leadership suits you best?

You can draft other questions depending on your priorities. Discovering if a candidate fits your company’s culture pays off. Attention to match issues keeps the team relationships healthy and provides a smooth workflow along the way.