5 Ways to Solve the Talent Crunch

It is undeniable that there is a massive talent shortage within the software industry right now. This is a problem that long predates the more recent, universal worker shortages and is a problem that will continue to get worse as more of the world moves towards living and interacting digitally.

Talented, inquisitive people are the core of Foci Solutions. We are nothing without the awesome developers and engineers who’ve chosen to build their careers with us. We return that loyalty with as much support and mentorship as we can provide. We’ve learned a great deal since we were just four people crammed into a small office. We’ve become extremely fortunate and successful at attracting, developing, and retaining top software talent. I want to share some of those lessons and observations both at the broader ecosystem level and as individual business operators.

#1 – Build, Don’t Buy

This is simply the reality of being a small company. We will not win in a bidding war for top talent with the likes of Google, Amazon, or Shopify. We hire team members based on their potential and not on the number of years with a particular technology and we invest in them to build them into better software engineers. This is effective as technology is constantly evolving and changing, but the core patterns, theories, and behaviours remain fairly constant. A junior team member who is highly curious, has an aptitude for learning, has good engineering instincts and behaviours, and is a good communicator can become highly effective very quickly with the right support system.

There’s also the simple mathematics of supply and demand. Doing a quick search for Junior Software Developer opportunities in Ottawa on a major job search platform returns around 20 results. Doing the same search for Senior Software Developer turns up around 280. There just aren’t 14x the number of senior developers as juniors. And there never will be. So if you’re trying to hire for experience, you’re competing in a low supply and high demand market. Simply put, investing in junior resources and building them up to be awesome makes mathematical sense.

#2 – Hire Teachers, not Just Doers

Hiring senior resources and asking them to spend the majority of their time writing code can provide immediate impact and productivity gains but to amplify their value over the long term, we want to tap into all of their years of knowledge, experience, tips and tricks and distribute that throughout the team. Having seniors spend more of their time acting as mentors and teachers will create a force multiplier effect, making your entire team stronger.

To do this effectively, focus more on their communication styles and willingness to mentor others rather than just their technical skills when interviewing for senior candidates, include mentorship of junior team members into their job descriptions and (most importantly) provide them with the time and the tools to do those things.

#3 – Communicate, Communicate, Communicate

Most of us are not great at identifying and articulating our learning and growth needs. This is particularly true for people working in task and productivity driven jobs like software development. It takes a tremendous amount of self-awareness to know what we’re not good at, let alone figure out what kinds of support we need to fill in those gaps. Consistent and frequent communications allows the team to collectively work through issues and identify things that each person can learn and develop to improve.

Implement formal code reviews, pair-programming, 1-on-1’s, quarterly learning reviews, basically any opportunity to talk about challenges, celebrate successes, and figure out how to do things better. This takes a lot of time, so it’s best to allocate budget to this. It will pay off in dividends.

#4 – Interview for Knowledge, not Skill

We’ve tried all kinds of things in an attempt to assess technical skills during the interview process such as live coding challenges and take home exercises yet never found a strong correlation between how a candidate performed at those activities vs how they performed on real projects. Even worse, those activities were extremely time consuming to administer and caused a lot of candidates to simply drop out of the process. What we realized is that asking someone to explain their code or how they solved a technical problem is a much better indicator of knowledge than a high-pressure, staged coding exercise.

Ask to see code that they’ve done instead, and get them to walk through it with you. Ask them to explain their design decisions, their thinking when they built it, and what they would do differently. You want to see if the person understands basic software concepts and principles, can think critically, can articulate technical concepts, and is able to learn from their mistakes. If the principles and concepts are there you can always teach them how to build a specific algorithm or use a specific framework.

#5 – Engage with Academic Institutions

Alright, this is a bit of a macro activity and frankly we haven’t been very successful at it. Universities and Colleges curriculums cannot keep up with the concepts and skills that the software industry needs for new grads to hit the ground running. We, as industry leaders, need to engage with academic institutions in our communities to help them modernize their programs.

Sure, there will always be a need for people to know Assembler and how to build Compilers, but that is not what the majority of the software industry needs today. If Computer Engineering and Computer Science programs were teaching about cloud computing models, 12-factor application design, Test Driven Development, APIs, application security, infrastructure as code, and other fundamental concepts that are widely adopted in modern software organizations their graduates would be better able to transition into real software roles.

The talent crunch can’t be solved by throwing money at it and having senior resources play musical chairs among the firms with the deepest pockets. We can build a better and more sustainable ecosystem of high quality software engineers by: constantly investing in their development; freeing up the flow of experience and knowledge within our teams; emphasizing the aptitude for teaching and learning rather than pure technical skill; and working with the academic community to ensure graduates entering the workforce have more relevant and up to date skills.