Work-In-Play Limits in Agile Software Development
In traditional waterfall projects, everything happens in sequence, so this bottleneck does not occur because it is planned in. For instance, the testing starts when all the development is complete.
However, in agile software development projects, the analysis, design, development, testing, etc are all happening in parallel during a Sprint, with the team’s efforts converging on completed features in a short time period; perhaps as short as 1 or 2 weeks.
If you have specialist roles in your team, for instance designers, analysts or testers, this can inevitably create bottlenecks, where the developers are waiting for visuals from designers, or testers are waiting for completed code from developers, or the release is waiting for testers to complete their QA.
A common bottleneck, at least in my experience, is for teams to start (and maybe even complete coding) more features than can be tested properly by the end of the Sprint, meaning that testing is the bottleneck and the release is delayed.
So what’s the solution?
The easy answer – of course – is to make sure you have enough resources, particularly in the more specialist roles, so there is always enough slack in the schedule to complete a Sprint without these bottlenecks occuring.
But in reality, the chances of the balance always being perfect (for every type of work you ever do) is low, so some bottlenecks are sometimes inevitable. And in these chellenging economic times, what do you do when adding resources simply isn’t an option?
One solution, coming from Lean agile software development practices, is the concept of Work-In-Play limits; a concept borrowed from Toyota’s practice of lean manufacturing.
This concept supports one of my 10 Key Principles of Agile Software Development, where I write about completing each feature before moving on to the next, making sure features are shippable at the end of a Sprint.
The idea of WIP limits is to try to ensure that you never start or complete a task that cannot be passed smoothly on to the next stage without blocking up the ‘factory line’. To do this means having a ‘pull system’ rather than a ‘push system’ and is intended to create a smooth continuous flow of work down the line.
For example, if a classic (and simplified) software development lifecycle is develop and test, testers would pull features from development when they are ready and have capacity to test. Developers would not push completed features to testers whether the tester is ready or not.
This is a simple concept, but like many things in agile software development, it’s different to what we’ve all been used to for so many years, so it takes a little thinking about!
So let’s say you set a WIP limit that no more than 3 features can be in play at any one time. You have 3 slots on the board for development, and 3 slots for testing. What happens when the testing slots are all full and the developers have capacity to do more?
If they think the tester will be done before they complete the 4th feature, they can safely start it. But what if they think they can complete the 4th feature before the tester is done? What should they do? Should they sit idle?
Maybe they could complete it and not check it in to the central source code until a testing slot is available. That’s okay, but you certainly don’t want your developers racing ahead of the tester and creating a pile of backlogged features that aren’t checked in.
Maybe they should do some other task? (for instance update documentation, or research a tricky feature coming up). Not a bad option if they need doing, but you really don’t want to invent work that isn’t necessary.
Personally, my preferred option is to help with the testing to clear a feature so the team can move on? Then the flow of work can continue, and the team is much more likely to reach a stage of completeness at the end of the Sprint, without the tester being overloaded and the release eventually being delayed.
If you do opt for this approach, make sure developers don’t test their own work, if at all possible, and have your tester still play a QA role and guide any testing that’s being done by others.
An interesting debate about WIP limits is currently occuring between two of the heavyweight thinkers of the agile community. Alistair Cockburn has been commenting on Twitter that WIP limits are for beginners, referring to them as ‘training wheels’. Whilst David Anderson argues on his blog that WIP Limits are for Adults too!
What do I think about this debate?
Certainly many parts of agile development are common sense. But we all know that lots of people don’t have common sense. And that in software development there are often many variables and keeping focus on something like this can be very difficult without some simple rules and guidelines for people to work to. That’s why agile works. Because it’s simple.
If Work-In-Play limits help some teams to keep focus on this key principle, help to start the right conversations when there are bottlenecks, and ultimately therefore help to ensure work is completed at the end of a Sprint, then I’m all for it.
Perhaps a more mature agile team might impose WIP limits temporarily on occassions when they can see that work is in danger of piling up at one stage of the lifecycle. In this case, WIP limits could be a useful tool to ensure the team has a complete feature set at the end of the Sprint, and not, for instance, a load of untested features.