Last year as I was working on a conference talk, I came across this labour market research conducted by the Australian Department of Employment on IT professions. The research found the rather shocking statistic that 45% of all senior “Developer Programmer and Analyst Programmer” positions were going unfilled, while that number was 47% for senior Web Developers. While we don’t feel this so badly at Zendesk given our amply stocked kitchens, juicy technology challenges and strong focus on a pleasant and respectful working environment, it is never a given that hiring at that level is going to be fast or easy. What really got me in the report though, was this sentence:
Graduate outcomes for students studying in the field of Computer Science (which includes the vast majority of students studying in the Information Technology field of education) have been declining for four consecutive years
I spend a bit of my professional life visiting schools and coding bootcamps. Encouraging budding software engineers to work hard, get into the industry and enjoy the many benefits of working in technology in the year 2017. So I was a bit horrified to read this sentence and look at the supporting data as it directly contradicts the rosy story I have been telling students.
Apparently only 26% of companies that employ engineers offer graduate roles!
This creates a world in which only 53% of Computer Science graduates manage to get a job in the field. The other 47% become disillusioned at the lack of available entry-level jobs and take their brains and talent off to do other things.
An unpleasant symmetry
Just last week I was chatting to a young lady that I mentor through a local university. She is in her final year of Computer Science and had been told by her lecturer in Web Development that there were no jobs in the field because WordPress and other such WYSIWIG offerings had made the job virtually redundant. Now the reason is exactly wrong, but the lecturer wasn’t too far off by saying there are no jobs. We as an industry have an incredibly restrictive entry pathway, almost half of IT graduates are forced into other industries and yet we can’t fill our Senior roles. What self-defeating, short-sighted thinking.
Looking at the expected growth in the industry over the next few years -significantly higher than other employment sectors – and the largely flat number of enrolments in Computer Science (it’s increasing slightly for male students but basically a horizontal line for women), we aren’t going to be able to continue the wasteful practice of squeezing junior engineers out of the industry. We are cutting off our own air supply. It’s time to stop seeing junior developers as optional extras and start recognising their worth, both short- and long-term.
Of course this doesn’t mean we all go out tomorrow and hire new teams composed entirely of juniors. We need to be intelligent and strategic about how we do it. Here’s a short list of things to consider to make it work for everyone:
Keep a Sensible Ratio of Junior to More Senior Engineers
Our last three hires were Junior (or Associate as we call them) Engineers, but this was into a team of eight Senior or mid-level Engineers (yes, the team is big, we work in smaller crews). Each of our Associates came with different levels of experience and education, each brought something unique to the team, and all of them work well together. This allowed us to hire at a junior level with only minimal disruption to team velocity. Our next hires will be at mid- or senior-level. So apply common sense when bringing on juniors, remember they will need more time and attention than experienced engineers and assess what your team can reasonably support.
Have a Strong Onboarding Process
This is great advice for any team but goes double for folks who may be coming in to their first job. Provide more than enough guidance so that a new hire isn’t left wondering what they should be doing, even if what they should be doing is asking for help or guidance. Nice long checklists, instructions, how-tos, links to tutorials and any other documentation you can provide should all be accessible from a central place. Every time you write something down you are saving your existing engineers from interruption and giving your juniors agency. Encourage new hires to add to and improve the onboarding guide so each hire makes it better.
Create a Strong Pairing Culture
The best way to learn to do something is to spend time with an expert. You currently employ experts in your codebase, most of whom will get a sense of satisfaction out of sharing their knowledge. With a strong pairing culture this comes naturally. If your development team is more likely to have headphones on and only communicate over chat this can be very daunting for a junior hire. You may need to artificially force it in the beginning with a pairing roster or WIP limits on the In Progress work column. There are a lot of stories out there about how engineers didn’t want to pair but once they tried it, loved it. Be careful though that any pairing guidelines you implement have team buy in, nothing kills the benefits of pairing faster than having mandatory, inflexible rules around it.
This doesn’t need to be a formal, tightly structured program. We hire and train up interns using the same process as regular developers, but with an emphasis on mentoring and learning rather than productivity. 1:1s with interns should be held frequently, goals set and feedback from the intern listened to and acted upon. Consider giving interns side projects that won’t integrate with your revenue-generating codebase so they always have something to make progress on, even if the rest of the team is unable to pair. Code katas, coding challenges and tutorials are all readily available too and should be seen as part of regular work for an intern.
At the end of an internship you’ll have a junior engineer who is already an expert in your tech stack, can hit the ground running and feels like part of the team. And if the intern isn’t what you are looking for there is a natural end to the relationship, making it a much lower risk than a permanent hire.
Focus on the Positives
It’s lazy to view junior engineers as a risk to your production code and a brake on team velocity. Compared to someone who has been pumping out commercial-grade code for years they will be slower and less knowledgeable. But they will also bring energy, enthusiasm, new perspectives (especially if you hire with diversity in mind), new ideas and a fresh take on processes that will be getting stale. The juniors we have hired are all committed to learning and absorbing information at an incredible rate. This hunger to get better continues even when they have achieved parity with the other engineers and will result in innovations that your longer-term employees won’t spot. The pool of diverse candidates is much greater at the junior levels as well, and companies like ThoughtWorks have used this to great advantage.
As an industry that will soon be facing even greater shortfalls in available engineers (100,000 in Australia by 2020) we can’t only focus on the next sprint, or the next quarter or even next year’s deliverables. We need to lift our heads, take a peek at the future and start to change course so that we feed our industry with vibrant, clever new minds. And we need to start now.