In the previous post we discussed what WIP (Work In Process/Progress) is, and how to track it. In this post I want to discuss why WIP limits are so important and how they contribute to improving the team's effectiveness and throughput.

# So There's This Little Law…

Little's Law describes the relationship between the average throughput in a system, the average process time (a.k.a. Cycle Time) for an item in the system, and the amount of items being processed at the same time (your WIP). For the mathematically inclined reader, this relationship is described in the following formula: **L= λ**

**W**, or in other words, the

*long-term average*WIP (L) is equal to the

*long-term average*throughput (

*λ*) multiplied by the average wait/process/cycle time (W).

This theorem is both simple and profound; while the formula is intuitively easy to grasp, it also means that it is *unaffected* by other factors such as the arrival process distribution, service distribution, order of process, or for all intents and purposes – anything else!

This law therefore holds true for both simple and complex systems of any nature.

Okay. So this is interesting (humor me here – let's assume that if you're reading this post you are finding this interesting) but what does this mean?

# Applying Little's Law to Product Development

If we play around with the formula, we will arrive at a way to determine the process time – or in product development terms, the amount of time to develop a feature – by dividing the WIP by the system throughput, or W=L/*λ*. This means that we can **reduce** the amount of **time** it will take us to **implement features **by limiting the amount of items we develop concurrently!

This too should be intuitive. Even if we completely ignore all of the disadvantages of multitasking, context shifting, resource allocation, deadlocking, and conflicting priorities, it is simple to see that if we could, for example, complete only 80% of the planned work, it would be more valuable to have 80% of our items 100% done and delivered, than to have started work on all 100% of our items, but each only 80% complete, and in no shape to ship. Yes in the described scenario, as a manager, you could find how to blame your developers for not completing 100% of the planned work, but this was preventable! That's on you!

However, there is another subtle application that is implied by the modified theorem. WIP *predicts *process time!

# Predicting Process Time based on WIP

Predicting process time is not new. We just like to call it estimating. Estimation is defined as making an extremely hopeful guess about the amount of time it will take to develop or (and?) deliver something, based on personal or shared past experiences (or more often, an arbitrary demand, dictated by someone in a higher tax bracket than the people doing the work). Okay, so perhaps it is not defined quite like this, but in all honesty it really should be.

Regardless of what technique (if any) you use to come up with your estimates, all of the data that feeds your estimates are based on the past. In other words, they are *trailing *indicators. This means that the numbers come after the fact – they could be used to explain the previous items' process time, and we statistically assume (read: hope) that they will hold true for our upcoming work.

By contrast, your WIP is a ** leading** indicator! This means that the WIP predicts (affects) the process time for items

*entering*the system, I.e. not yet developed.

Let's look at the following Cumulative Flow Diagram from a VSTS project:

Let's try to reduce the work in progress. We will do this by focusing our efforts on closing items that are already active instead of beginning work on new items. This will be represented by taking items out of the **Active** state, and putting them back in the **New **state, and in return, moving items from the **Resolved **state into the **Closed** state. Doing so will result in the following modified cumulative flow diagram:

Note that as our WIP is reduced, so does our process time! We have reduced the time to deliver an item – any item – doing nothing more than limiting the amount of work the team processes concurrently! And this doesn't even account for the extra benefits that knowledge work such as software development derives from focusing on a single small unit of work!

# Conclusion

In this blog post we've discussed Little's Law and its implications for product management. Likewise, we demonstrated the importance of WIP limits as leading indicators for process time, and how reducing the amount of work we have in process concurrently reduces the amount of time to process items through the system. Armed with this knowledge I hope you will be able to make use of this because all you need to do is *not* take on a new job before you are done with (most of) the ones you've already begun.

Stay lean because you can(ban),

Assaf