Work-In-Play Limits in Agile Software Development

Work-In-Play Limits in Agile Software DevelopmentA common problem in agile software development – is bottlenecks that hold up the team’s progress during a Sprint or iteration…

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.


6 Responses to “Work-In-Play Limits in Agile Software Development”

  1. Ilja Preuß says:

    Isn't it "work in progress"?

  2. Sylvain St-Germain says:

    I am not aware of the debate between Cockburn and Anderson but admittedly a team can decide to be "agile" about it and define the rules for their WIP queues. These rules can also have flexibility.

    The major benefit for these queues limits are their inherent promotion for collaboration.

    Read my post:

  3. Kevin E. Schlabach says:

    I've been following the Kanban movement for months now and I thought it was "Work in Progress". The word play doesn't translate well and might be confusing across language barriers.

  4. Derek Morrison all about product management says:

    I think the approach depends a lot on the size of the team and the type of work you are doing. Small teams doing a series of BAU sprints that set aside 10% to 20% for support tasks, in my experience, do not often have problems with bottle necks. However larger teams working on critical projects come across bottle necks more frequently. I’ve known team to do as you mentioned and not check in code if it’s going to cause a bottle neck. My preference is to ensure that there are enough stretch tasks items that do not require coding e.g. R&D for a coming sprint.

  5. Ray says:

    Developers assisting the tester works in my team and has enabled us to deliver all committed user story points in the last 4 sprints. Without this approach, there would've certainly been a bottleneck. This also helps the team pull together to ensure tasks are complete early enough to test. We commit as a team and deliver as a team. Check out one of my blog posts on how this can be achieved without jeopardizing quality at

    I'd also like to point out Derek's preferred approach would more often than not cause a bottleneck, resulting in a failure to deliver all committed points. I fact, I worked on a high profile project last year and the only sprint that we delivered all points was when the developers helped with testing tasks.

  6. Carl Hubbers says:

    Great post.

    I’m with Alistair Cockburn on this. WIP limits are great while learning about what the Team is capable of. But when they get more experienced/mature the Team should be trusted to back themselves and go for it if they think it means they will get more Stories DONE. They are the ones who made the commitment after all, so it’s up to them to decide how they hit that target.

    In my experience Teams almost always overextend themselves a few times before they learn the right mix of confidence and caution.

Leave a Reply

What is 10 + 1 ?
Please leave these two fields as-is:
Please do this simple sum so I know you are human:)