When we talk about a skills shortage in the software development industry, everyone nods their heads. This is a good and a bad thing. Good, because at least it is a generally acknowledged problem. Bad, because the thought is so pervasive that we simply accept it as both true and inevitable. And then we move on.

But if we want to solve the problem we need to understand how this problem manifests itself for different role players. I’ll start with the one that has affected me most over the last few years: How the skills shortage impacts a typical tech lead

The Tech Lead takes full and final responsibility for the technical delivery of a solution. This statement has some significant implications when analysed through a skills-lens. Let’s dig deeper..

As a tech lead, it is inevitable that some team members will be missing a skill (or three) that is critical to the delivery of your project. This is par for the course, and in today’s rapidly changing development world we have gotten used to the idea of learning new technologies on the job.

The tech lead would typically follow a skills-transfer approach, like Mob programming or 1-on-1 coaching. This approach works well, but if the bulk of the team needs this kind of assistance, it starts to become a substantial time-investment.

And when the project deadlines start to loom you’re faced with a serious “Sophie’s Choice” scenario:

red and yellow, red and yellow, red and yellow
Photo by Robert Anasch / Unsplash

Option 1: Neglect the team’s development, and just get the job done yourself

Option 2: Sacrifice the project timelines for the longer term team capability

I’ve faced this choice many times and my natural tendency is to take Option 1. However, I’ve learnt that Option 2 has the better long term implications. However, your decision will be strongly affected by the type of project, the contracting model and the current position of the planets

Which has lead me experiment with “guided self-learning models” (as opposed to self-directed learning). What I mean with Guided Self Learning is the following:

  • The tech lead assesses which skills are critical for different roles on the project
  • The tech lead identifies online learning material (tutorials, MOOCs, etc.) that teach these skills and makes these available to the team
  • The tech lead informally follows up on progress
Photo by Wes Hicks / Unsplash

In theory, this approach has many benefits, but it has never really worked perfectly in my case. The failures tended to fall into these categories:

  • Learners lose interest if the learning material is totally detached from their work responsibilities.
  • The learning material selected are not curated/reviewed carefully enough and sometimes teach outdated material. This is mostly due to the vast amount of learning content that is available online.
  • Learners feel like they are able to find better resources themselves

However, the biggest drawback of this approach is that it could lead to learners feeling isolated from the project - especially when they are not given any real-world tasks and focus exclusively on the learning material.

To address this issue, we are currently exploring ways to mitigate some of the negative implications while retaining the positives.

Follow my blog (http://devskilldojo.com) and twitter feed (@devskilldojo) for the blow-by-blow on this journey.

References: