Hand-offs are Productivity Poison

Software development always involves handing work over between team members, and this slows us down. Some hand-offs are obvious, but some can be harder to spot.

In a typical software team, you probably have some developers and some testers. Generally the developers will build something and the testers will then test it. This creates a hand-off — a need to move work from one person’s to-do list to another.

But these two sets of people have very different kinds of work to do and often operate at different speeds, meaning that queues and bottle-necks can build up between them. This situation will probably be familiar to anyone who’s worked in a software team for any length of time, and its something that a lot of agile methodologies can help with — by limiting development work into sprints, for example. And because we do these hand-offs every day, we eventually get into a rhythm that helps to mitigate them.

It’s the hand-offs that occur less frequently — or less obviously — that can really slow us down, however.

Recently I discovered a hand-off that had probably been causing slow-downs for a while without us realising it. The team I’m working with looks after several independent applications that provide various APIs. Occasionally they have a need to create a new one of these applications, and that means tooling up our continuous integration server to build, test and deploy a new codebase.

This doesn’t happen very often, perhaps once every two to three months, but when it occurs the developers have to ask someone to configure the CI server (unfortunately a fairly complicated task at the moment), and that creates a period of waiting and hence a slow-down.

Having recognised this problem, the solution is of course obvious. The developers should be able to tool up the CI server for a new application themselves. To do that, though, we’ll need to simplify the process and implement some standardisation in the way we build and deploy software. In our case this is a large-ish effort, but it should be worth it to avoid a hidden hand-off and free up a little bit more productivity for the team.

So, perhaps you’re being slowed down by hidden hand-offs too. It’s worth thinking about ways to fix some of those awkward inter-person dependencies that occur just infrequently enough that you never quite get around to sorting them — the time savings might just surprise you.

Jez Halford is a software development consultant helping teams to deliver better software, more frequently. Visit jezhalford.com to find out more.