Recruiting the right group of people is one of the most important parts of building a top software delivery team. In this article, we take a look at some things you should consider whilst recruiting, and a few things that you should try to avoid.
Create a cohesive culture
A key component of building an effective software delivery team is creating a cohesive culture. A cohesive culture is achieved when a team feels empowered to participate, can collaborate effectively and gets recognition for its successes. To achieve this you need the right leadership, the right mix of experience, and people with character traits that encourage cohesion.
When recruiting, you should be thinking about how to achieve a cohesive culture. Often people recruit with specific technical skills in mind, but we've found that it's just as important to consider softer skills such as:
- Is this person a team player?
- Are they able to communicate effectively?
- Do they take responsibility or blame others?
- Do they have a positive outlook?
Although there isn't a 'one size fits all' approach to creating a cohesive culture, there are certainly signs that you can look out for during an interview process and, when you see them, question whether the candidate is somebody who will help encourage cohesion, or fight against it.
Don’t hire rockstars, ninjas or self-proclaimed superstars
Everybody wants to hire incredibly talented people, but never hire anyone who considers themselves a 'rockstar' engineer. It's a sign of arrogance and an inflated ego, and they're a sure fire way to create a divided team. Of course, you want exceptional people on your team, just make sure they're grounded and able to put their skills to good use, improving the team.
It's nearly always better to recruit through your existing network. Either through people you have worked with previously, or through contacts your team have within the industry.
Your team should understand the needs of the organisation and what it's like to work there. Their relationship with a candidate will mean they already know a lot more than can be discovered during an interview process.
These kind of network referrals are the best indication you'll get as to whether or not a candidate will be successful, so favour them over other recruitment sources.
It has become common for organisations to offer incentives to staff to help encourage recruitment referrals. In our experience, awesome people will automatically want to bring their most talented friends and acquaintances along. Offering incentives can help and may result in a few additional hires, but it's questionable as to whether carrot and stick motivation ultimately leads to stronger teams.
Our advice would be to focus on building a great culture, that your team are proud of, and their network of acquaintances will be eager to join. You can still thank people for referrals but, hopefully, you'll find that by flipping the motivation model from extrinsic to intrinsic, you'll end up in a happier place.
Strive for diversity
It’s no secret that many software teams struggle with diversity. While there are some factors limiting progress, diversity is something that needs to be taken into account when recruiting. There are steps that you can take, such as:
- Helping people to reduce unconscious bias
- Capturing and reviewing data that highlights diversity challenges within your organisation
- Scrutinising job advertisements and internal practices to ensure they don't unintentionally discourage certain demographics.
We've made significant progress in recent years, but our industry has a long way to go in terms of diversity, and there's a lot we can do to create an environment that is welcoming of people from any walk of life. Bear this in mind when recruiting!
Keep it interesting, increase retention
One of the challenges you'll face after you've recruited some good people is keeping them around. If they are talented and based in a decent location, then they are likely to have many opportunities open to them.
It's common to see companies offer perks and incentives to help encourage employees to stick around. In our experience, the most important factor is ensuring they can keep on learning, improving and getting better. This means having work that is challenging, and is going to push them to improve every week. If this dries up and day-to-day becomes mundane, you'll often find people won't stick around.
Where possible, you should look to take money off the table and pay above industry wages. This often helps to attract a higher calibre of individual (providing you're recruiting well!) and shows your team that you value them.
This approach is particularly relevant in fields which are highly leveraged and where software delivery is generating a good ROI. When this is the case, it can make sense to pay well above market rates and get above-average performers, as it can be a win for the organisation and a win for the employee.
Of course, this approach is dependent on an organisation being in a very strong and stable financial position, which tends to limit the number of organisations that can do this.
Don’t use contractors
The software industry has a large number of people who work on a contract basis. In our experience, it's inadvisable to build software teams comprised primarily of contractors.
We have found the most efficient teams to be those who have worked together for extended periods of time. This typically means full-time staff. We tend to find contract staff can take a short-term view, and this can mean your delivery teams are in a constant state of flux.
When you have to use contractors, try to use them sparingly. We've seen technology teams 100+ strong, comprised of over 90% contractors and struggling to deliver. We would advise keeping contractor levels to a minimum at all times.
It's human nature to avoid making difficult decisions. Nobody wants to be fired or to have to tell someone that they no longer have a job. However, when faced with this scenario, it's vital that you act quickly and let them go as soon as possible.
It's a sad truth that many organisations end up carrying underperforming team members for years. This can have a big impact on morale and wider team performance, so it's important that the situation is dealt with.
If you're hiring junior team members, it's important that you factor in some of the challenges that this can bring. Juniors often require significantly more support than expected, which can impede the team and impact ability to ship quickly.
Sometimes you need to slow down in order to speed up, and we think this is particularly relevant when onboarding junior members into a team.
Make sure your environment provides plenty of support for juniors and opportunities to learn. Things like mentors, pair programming, regular code dojos or code katas can all help, and over time the level of support and guidance required should drop significantly.
Colocate or remote
Nowadays it's common to see companies offering remote roles. We see some significant benefits to this, such as a much wider talent pool, ability to get more focused time and a better work-life balance. However, there are trade offs. One example is that it can be far more difficult to achieve a cohesive culture team when you've got people working remotely.
We've found a good balance is to have people working remotely part-time, so maybe two or three days per week. This has given us some of the benefits of remote working, with some of the upsides of colocation and has worked well.
The first few weeks with a new hire is a crucial time. They are going to decide during those weeks whether the company is actually a good fit and whether they have made the right choice.
Ensure you set aside ample time to onboard new starters properly. Make them feel welcome and help them to get to know the team and understand how things work. Set very clear objectives, so they know what they are working towards and what criteria you've got for reviewing their performance during their probation period. Talk with them regularly and provide them with lots of encouragement and direction around areas they are doing well and could be doing better.
Retrospecting the interview process
As with any process, it's important to frequently assess performance and find ways to do things better. Recruitment is no different. Set aside time to talk to candidates about the recruitment process, to find out what has worked well and not so well for them.
We've explored running facilitated retrospectives with candidates we've employed and rejected. This has helped us understand what the next evolution of an interview process might look like and steps we would need to take to get there.
Recruiting a strong software delivery team is tough. It requires a huge amount of effort, starting with finding the right people, then convincing them to join and moulding them into a cohesive team that works well together. If you can achieve this, then you've done extremely well, and you are well on your way to building a high-performance software team.
You'll find that once you've got the first batch of great people onboard, it should start to get easier. Talented and motivated individuals tend to attract other talented and motivated individuals. With strong management, your team should continue to grow and improve for years to come.