How to Hire Great Web Developers

Hiring the right people is one of the critical components of company success, hands down. They are the ones who deliver excellent work, generate fascinating ideas, overall improve processes, and embrace the company values and culture. Indeed, companies are all about people, and that’s why at LeanyLabs, we’re quite picky about the people we hire.

Talented web developers are in high demand right now: everyone needs them, and they’re hard to find. But we decided to share our process of hiring skillful engineers to make your life a bit easier. Maybe our tips are just what you need.

Hiring Web Developers 101

Hiring great web developers consists of three steps: searching, interviewing, and, well, hiring.

First, you have to devise a detailed and attractive job description and establish a flow of candidates for your job interview. During the meeting, you get a chance to find out what kind of person they are, test their skills, and decide if they’re an excellent fit for the team.

After you’ve found the perfect candidate, don’t just end on signing the employment contract. You should make sure the engineer feels comfortable in your company. Help them with onboarding, and save yourself some space for maneuvering in case you’ve made a mistake. Every step is equally important, and we’ll cover them all in detail below.

When It’s Time to Hire More Engineers

It may be hard to tell the exact time you need to hire a new developer. A bit too soon or too late usually doesn’t make much of a difference. However, making sure you’re hiring for a good reason is extremely important. For example, if there’s more work to be done than the current team can handle, that’s a valid reason.

Before even starting the hiring process, you have to make sure you actually need another developer. Ask yourself these questions:

• Are all of my current developers busy for the next three months?
• Will the project benefit from having another developer?
• Do you guarantee to have at least six months of work for a new person?
• Is there a backup plan if that work becomes irrelevant for some reason?
• Are you comfortable with firing someone if you hired the wrong person?
• Do you have the technical expertise and enough hiring experience?

Answering “Yes” to all of them is a definite sign you should go ahead with hiring.

How to Find Great Web Developers

In an ideal scenario, great web developers would be looking for you, not vice versa. Rumors about your company, its culture and benefits, exciting projects, technical challenges, growth perspective, active community around your company, and personal connections all contribute to this tactic’s success.

In the real world, however, there’s fierce competition for rockstar JavaScript developers. On top of that, most great engineers are happy with their current jobs and aren’t actively looking for a new one. You have to put a lot of effort into making them even to consider your vacancy.

Preparing an Attractive Job Description

To create a good job description, you have to visualize a new developer on the job as if you’ve already hired them. Answering these questions would help you discover more about your vacancy:

• What are the responsibilities?
• What are the routine, everyday tasks?
• What part of the project would they be working on most of the time?
• How would they communicate with the team?
• What would make them happy and more productive?

You should know if you need a front-end, back-end, or full-stack engineer, which technologies are critical and which are optional and quick to learn.

At LeanyLabs, we have two types of hires: for a remote team and MVP development.

MVP development gives us complete freedom to decide whom exactly we need to strengthen our team. They would be working on different smaller projects and not directly for a specific client.

With team extension, however, the skeleton of the requirements comes from the client. We also know the project and its internal needs well. To land a better hire, we offer our suggestions, prioritize the technologies and prepare the final job description ourselves. The person would be working on the client’s project for an extended time and communicating directly with their in-house team, so it’s crucial to get the client’s feedback on every stage of the process.

We always make sure to prepare a detailed job description to attract the right people. It should include all the required and good-to-know technologies, a fascinating and challenging project description, and a summary of the candidates’ responsibilities and day-to-day duties.

People love to be a part of something bigger, so it’s important to tell them more about your company and your project from the very beginning. Don’t forget about the benefits like vacations, sick leaves, cookies, and more. But, be careful with the extrinsic incentives based on performance. University studies suggest that those may have a detrimental effect on motivation.

How to Get Candidates for the Job

Now that you have an attractive job description, post it on your website and share it with your community on social media like LinkedIn, Twitter, and Facebook. Take advantage of your network: maybe someone on your friends list grew tired of his job and is secretly looking for a new one. The more interested eyeballs you can get, the better.

Feel free to also post it on every job board you might find. Job board posts usually cost money, but it’s often a high ROI, even if it brought you a single decent candidate. We already know what job boards work best for developer positions here in Ukraine, so we can save ourselves the trouble of posting vacancies on all of them.

If you’re looking for remote developers, we suggest posting your job description on international job boards like Jooble(https://jooble.org/). These huge boards reach lots of candidates. Also, they’re integrated into most major ATS, and you can post new jobs with a single click.

Essential and challenging positions, those that require scarce specialists, demand active recruitment. The semi-passive approach just won’t work in time. On the other hand, active recruitment is hard. It’s very similar to sales, with lead-generation targeting potential candidates and cold contacting them to check if they’re interested in the vacancy.

Working with a Recruitment Agency

We know the basics, but considering the urgency and the time it takes to headhunt candidates, we trust this job to expert recruiters. They have large databases of candidates, which allows filtering them by technologies and experience to contact potential candidates instantly. They also have lots of experience in recruiting, searching, and cold contacting candidates on LinkedIn and other platforms where software engineers hang out.

The terms and fees are often very similar. Freelance recruiters are usually cheaper but provide less relevant candidates than expert agencies. The price is typically 100-150% of the monthly salary for a vacancy with a three-month probation period and a free replacement if the candidate doesn’t fit.

When you go exclusively with one agency, the fees might be lower as they’re guaranteed to get paid for their effort. Agencies may also have a fixed cancellation fee after they’ve provided some relevant CVs, but the position was closed without hiring anyone from them.

As with all services, different agencies have drastically different performance. Some are focused only on specific software development positions, while others can find anyone. It might be hard to pick a few great agencies from dozens that exist on the market. It’s also too expensive to give them all a try.

From our experience, the rule-of-thumb criteria for a high-performance agency are their openness, willingness to share knowledge, and ability to provide rough estimates for a given vacancy based on their experience and situation on the market. Usually, we go exclusively with one specialized agency that has proven to be the best over time.

Screening Web Development Candidates

When candidates send us their CVs, the first thing we check is if it fits the position. Listed technologies matter, but it’s not the single, most important criterion.

We almost completely ignore the “ratings” people give frameworks and libraries as they are very relative. Take, an excellent engineer, for example, who might give their knowledge of C++ 5/5 and 2/5 points for React only because they know all the nuts and bolts of C++ after 12 years of experience with it but have worked with React for only three years, and considers this junior-level.

What we look carefully at are companies and projects the candidate has worked on before. Companies combined with the position might tell a lot about the candidate’s attitude. Small companies are usually dynamic, with more active employees, while mid-sized companies and big enterprises have more room for laziness, pointless meetings, and other forms of wasting time.

Projects can tell a lot about the technologies the developer has worked with and the minimal depth of their knowledge required on the previous job. Playing an essential part in a technically advanced project makes an excellent first impression, but we still trust our interviews more.

Usually, up to half of the collected CVs turn out to be irrelevant for the position. We kindly explain this to the candidates, sharing more details about who exactly we’re looking for in case they wish to tell their friends about our vacancy.

When we see someone who’s a promising candidate, we try to set up a quick call to answer questions, learn more about the person, and get a rough idea of their soft skills. During the call, we talk more about the company, the client, and the position. Sometimes candidates have concerns that are also worth debunking, like clients from a specific location, company size, employee benefits, and others.

When the candidate is not available for a phone call for a long time, answers to messages once in a couple of days, or we have trouble scheduling an interview for other reasons, we take that as a big red flag and turn the person down. Why hire someone who shows little to no interest in the position?

A Test Web Project

Some companies send a test project to candidates before inviting them for an interview. It is usually a clear, self-sufficient task that somehow mimics the day-to-day craft on a real project, about 2-3 hours of effort. The code quality, design decisions, and attention to detail might tell a lot about the person who wrote it. You can check if what they called “done” meets your vision of “done” and if they were too lazy to go a bit further than required. But be cautious: people might be inclined to cheat, ask for help, or ask someone else to do the task for them.

We usually don’t bother candidates with test projects. Our way is to give a bit more complicated design or architectural test problem during the interview, follow the person’s thought process, and ask leading questions when needed. This gives much more insight than just code-reviewing the test project since writing code is much easier than deep thinking.

Hiring the Best Web Developer

An interview is the best way to learn more about the candidate’s personality, knowledge, skills, and expertise. At LeanyLabs, we have one person for soft skill evaluation and one for testing the web development expertise. A tech lead of the project we’re hiring for knows its needs best and usually is the one conducting the technical part of the interview.

We like it when other team members are also listening since they will be the ones working closely with the hired candidate. Their opinion also affects our hiring decision.

We don’t mind saving the commute time for a candidate by conducting an interview online, especially during the COVID-19 pandemic. The existing variety of communication and collaboration tools is more than enough to simulate the experience of a traditional offline conversation. The interview roughly takes up to 90 minutes, but we do skip some topics to save time if we’re sure the candidate is unsuitable for the position.

The Soft Skills Interview

During the interview, it’s vital to watch out for red flags in the person’s behavior. Testing hard skills is relatively easy when you’re an expert yourself, but with soft skills, things are trickier.

Tell them everything about the vacancy again and look at their reaction. Note things that resonate with the candidate. How does that align with the company culture? It’s worth asking about their previous work experience. What they liked or didn’t like about it. Why are they switching jobs? Ask them about their contributions and failures. What drives them, and what annoys them? How do they handle teamwork issues and conflicts? Give them a hypothetical situation if they don’t recall examples from their experience.

Make sure the candidates feel comfortable asking any questions during the whole interview. When a person is active and engaged in the conversation, it’s often a good sign. Keep in mind, though, that candidates might be nervous, especially junior developers who haven’t been on a lot of them yet.

The whole point of this part is to figure out if the candidate would be the right fit for the team and the company, assuming their development skills are excellent. We’re looking for active doers who deliver, not someone lazy, passive, and with a logical excuse for everything. Good command of English is a must, and excellent communication skills are a huge bonus, especially if we’re hiring for team extension.

Web Development Hard Skills Interview

This part usually starts by asking basic questions to draw the limits of the candidate’s knowledge. We gradually dig deeper until the candidate follows. Asking academic questions doesn’t make much sense, so we focus more on the technologies and practices necessary for the position.

Our interviewers prepare a custom plan for every vacancy. As an example, TopTal has a good list of questions for a generic full-stack position in their Web Developer Hiring Guide.

A person’s reaction to not knowing something or being wrong can give us unique information about them. Telling it upfront is much better than trying to make something up and collapse under more details. The latter candidate would write spaghetti code full of copy-paste from the internet without fully understanding what it’s doing first, guaranteed.

If a person admits they don’t know something but makes logical assumptions instead of lying or guessing, it’s a good sign since it gives some insight into their thought process. We tend to ask more open-ended questions to hear a person’s perspective on the topic and make it harder to prepare solely for the interview by reading common interview questions.

After a quick assessment of a person’s knowledge, we go to the design test problem. It’s usually close to a real-world example of the UI architecture, back-end design, or system architecture, depending on the position. The task isn’t directly related to the project we’re hiring for but requires the same technology stack, experience, and thought process to solve. There’s no single right solution, and we’re more interested in the candidate’s thinking process, the mistakes they make, and how quickly they realize them.

The questions candidates ask give you a hint of their concerns and what’s going on inside their heads at the moment. If they don’t ask the right questions, we try to lead and push them to realize the mistakes and downsides of the offered solution. This is the most critical part of the tech interview because it’s similar to working on a quite complex project together. Writing code is straightforward. Thinking is not.

We finish the web development interview with questions about the candidate’s most challenging tasks and achievements. It gives us an idea of what the person considers challenging and whether they prioritize technical implementation of the feature or the provided business value.

Lastly, we provide examples of the work the candidate might be doing on the job and ask for some quick ideas on how to approach it just to test how relevant their experience is for our position in general.

Candidates usually have some questions we answer after the interview to find out more about the project we’re hiring for and our company in general. We instruct them on what would happen next and do our best to give them feedback on the next day after the interview. Having an engineering background ourselves, we know how annoying those week-long delays from most companies are.

Making the Hiring Decision

After the interview, it’s essential to fill out the candidate profile while your memory is still fresh. We keep those profiles because sometimes candidates might not fit the current spot but are perfect for our possible future vacancies.

For example, a full-stack developer might be lacking back-end experience but shines on the front-end. A senior developer might know a lot and design great code, but lack experience with modern microservices or serverless architectures required for the project. A middle developer might have excellent hard skills and good written English, but a gap in spoken English, which is critical for the remote team.

We discuss all our hiring decisions with the team. Interviewers share their thoughts, and together we decide if the candidate should go further. It’s crucial to find a balance between soft and hard skills. Bad soft skills will ruin the team and undermine the whole company, so it’s better to fire that person sooner than later. Low hard skills might be an issue if the candidate has a ton of experience working on previous jobs. They might not learn fast enough, don’t have the desire for knowledge, or simply are too lazy. Lack of experience is a big no-no for the position that requires immediate output and not spending time learning new technologies.

We’re ready to hire new developers for an MVP team as soon as we’re sure they’re right for us. But when it comes to team extension, we arrange another interview with the client’s team first. It’s usually similar to ours, and our team leader also participates to take notes, provide feedback, and discuss the final decision with the client.

There are usually two types of good developers: superstars and rockstars. According to Radical Candor, superstars are more ambitious and always want to grow, while rockstars are just damn good at what they do and want to keep doing it. Rockstars are excellent, reliable deliveries with incredible technical expertise. Superstars want to be closer to the business, be more in control, and aspire for managerial positions.

We keep this in mind when hiring and try to balance our company with both types. It’s not as important as other factors when selecting candidates for a new position, but it plays a significant part in our company’s future career development. Overloading rockstars with new responsibilities just doesn’t work, while they’re better than superstars at what they do most of the time.

Monitoring the Hiring Process

The hiring process is often slow, and you have to make sure it doesn’t take up more time than expected. In general, you should have an idea of how many candidates you should get for a position every week, how many candidates it takes on average for hire, and how much time is required. Experience and good software are essential here.

At LeanyLabs, we can usually hire good junior developers in less than two weeks. Finding a middle web developer should take up to a month, while finding a great senior developer might even take two months and 20+ interviews.

It also depends on many factors, like recent major layoffs in big companies, the required technology stack, demand spikes, and sheer luck. Knowing those numbers helps figure out if the process is going as planned. What if the recruiting agency you’re working with gets a request from a more prominent company that asks for similar developers and all good CVs go to them? The agency might not tell you that.

If you’re not getting enough candidates, it might be due to poor job descriptions, a unique technology stack, or low salary. Check the average wage, for example, on Glassdoor for a similar position in your location when crafting a job description. Technology and experience with their supply and demand play a significant role in salaries, not the effort.

For example, in Ukraine, senior JavaScript and Python developers are more expensive than C#, Java, or C++, though we might argue that the latter have more knowledge and experience to be called senior developers.

But remember that salary alone isn’t enough to motivate an exceptional professional. In his book “Drive: The Surprising Truth About What Motivates Us,” Daniel Pink wrote:

Of course, the starting point for any discussion of motivation in the workplace is a simple fact of life: People have to earn a living. Salary, contract payments, some benefits, a few perks are what I call “baseline rewards.” If someone’s baseline rewards aren’t adequate or equitable, her focus will be on the unfairness of her situation and the anxiety of her circumstance. You’ll get neither the predictability of extrinsic motivation nor the weirdness of intrinsic motivation. You’ll get very little motivation at all. The best use of money as a motivator is to pay people enough to take the issue of money off the table.

Onboarding Web Developers

Congratulations!

You’ve successfully hired an excellent candidate! Now, someone has to help them figure out the architecture and code structure of the project, so decide on that person in advance to avoid surprises. We plan this upfront and appoint someone from the team, usually the team leader, for the onboarding process before even posting the job description. It gives them time to prepare and make sure the relevant documentation is up to date.

It’s essential to make sure everything is waiting for the new employee. And we don’t just mean the table, chair, monitors, laptop, and a contract laying on that table. Your new employee might need something small and unique to feel important, be productive, and deliver astonishing results. Kindly ask them if there’s anything more you can do. Attention to those details matter.

But regardless of how good the new engineer is, you should always have a backup plan in case you hired the wrong person. At LeanyLabs, we have a three-month probation period with the same pay, most of the benefits, and a smaller termination notice period. This gives both us and the candidate time to get to know each other better and rethink the decision.

After all that, we’re happy to have another great developer onboarded in our team.

Conclusion

People are the most valuable asset for many companies. Hiring the right ones is a long and expensive process, so be prepared for that and don’t compromise on quality or look for shortcuts.

Make the job description spotless and market it everywhere. The best talents are always busy and too comfortable to look for new jobs themselves, so you have to proactively hunt them. It’s critical to evaluate both the hard and soft skills of candidates and communicate everything with the current team to make the right hiring decision. Yes, it sounds tedious, but when the right person is hired, you’ll see that it was all worth it. Good luck with hiring!

If you consider hiring a remote team, feel free to book a call with us using the form below.