Ok, you’ve got your Value Stream Management system all set up. You’re tracking ideas from their creation to the moment they’re delivering value from your organization. You’re monitoring your value stream metrics. Fantastic!
Now what? Find the bottlenecks in your Value Stream! In this post we consider value stream bottlenecks, and how to use HCL Accelerate to detect and mitigate their appearance before they steal efficiency from your value stream.
Why track bottlenecks?
One of the best ways to see a return from your Value Stream management efforts is to find the bottlenecks in your value stream workflow. Bottlenecks rob efficiency from your well-oiled software development machine. By identifying and correcting bottlenecks in the value stream as they occur process and workflow hiccups and inefficiencies can be avoided or eliminated before they start incurring significant costs. Fortunately, value stream management tools like HCL Accelerate provides both the data necessary to find bottlenecks as they occur and intelligent monitoring capability to avoid their efficiency stealing consequences all together
What is a bottleneck?
Let’s get a little formality out of the way: A bottleneck is a restriction in local throughput that limits the global throughput of a system. In other words, a value stream can’t process more work in given amount of time than the most constrained part of that value stream. For a system with uniform workloads (where all work items are the same and enter the system in evenly spaced intervals) the expected throughput, local or global, is just the ratio process capacity (how many items can be processed in parallel) to expected processing time (how long does it take to process one unit of work). In such uniform systems finding bottlenecks is easy; we just have to find processes in the value stream where either the capacity is limited, or the processing times are large.
Knowing capacities and expected processing times is important for non-uniform workloads too, but finding bottlenecks is harder for real world workloads. Not all work in a software development value stream is created equal; different work items require different amount of effort to complete, work items have interconnected dependencies that determine how they collectively navigate the value stream, work doesn’t enter or exit the value stream at regular intervals. All of these considerations can produce transient bottlenecks beyond what would be revealed from a capacity/processing time analysis. Real world bottlenecks can be complex, but fortunately armed with the right data, bottlenecks in the values stream can be found, corrected, and ultimately prevented.
How can I find my bottlenecks?
As with most endeavors in software development, an effort to find bottlenecks in your value stream should begin simple; don’t overlook the basics. Is any process in the Value Stream consistently under resourced? Do any processes in the value stream require a processing time that is large compared to the value streams lead time?
You may well already know the answers to this and have procedures to proactively mitigate capacity and expected process time bottlenecks. If not get the data to find out if these systemic bottlenecks are slowing your value stream. What is the time-in-stage for each process in your value stream? What is the average load of each stage and what resources are dedicated to servicing those loads? Fortunately, HCL Accelerate provides not only the data to answer these questions but also automated monitoring and alerting to tools to make capacity/processing time bottlenecks visible.
Extending beyond simple capacity/processing time bottlenecks we encounter the bottlenecks introduced by practice methodologies. We often select our development practices to maximize the local efficiency of a specific task without considering impacts on the global value stream efficiency. For example, one common practice to lower transactional overhead and context switching costs is to process work through a specific value-add operation in batches. A batching practice can increase efficiency across the value-add operation for which it is employed, however it can also lower the global efficiency of the value stream by disrupting continues flow downstream. Stages downstream from a batching process can experience alternating periods of under-utilization and over-subscription, greatly reducing their ability to work at optimal efficiency. Finding bottlenecks produced by practice methodologies is a bit trickier than simple capacity/processing time bottlenecks, because the bottleneck can be produced by a locally optimized value-add process, so if we look at our value stream metrics for the stage that produces the bottlenecks everything looks great! Instead we need to focus on the flow patterns through each stage and how those patterns impact downstream processes. Frequent spikes and valleys in the time-series throughput can be a leading indicator bottlenecks introduced by practice methodologies. HCL Accelerate tracks global and local throughput for all your value streams and also provides user alerts when practice methodologies are introducing bottlenecks into your value stream.
The next type of bottleneck we will consider is the hallmark bottlenecks of the software development value stream; non-uniform workload bottlenecks. In software not all work is created equal; we’re not cranking out identical widgets, we’re engaged in a complex and creative endeavor where every unit of work is unique! Software work has an inherent heterogeneity in complexity of work, development resource requirements, and inflow to the value stream. This means that even if my value stream has perfectly balanced capacity/processing time measures and all my practice methodologies are optimized globally as well as locally, bottlenecks can and will still occur. Uneven flow through the system will periodically produce queues in individual stages or starve other stages of work items resulting in lower value stream throughput. Fortunately, with careful monitoring value stream stage loads and throughput bottlenecks produced by non-uniform workloads can be detected and mitigated before they incur significant costs to the value stream. Even better HCL Accelerate knows what to watch for and can detect and alert the user as non-uniform workload bottlenecks begin to develop.
How can I fix bottlenecks?
Knowing how and where bottlenecks occur in a value stream really is the most daunting part of bottleneck mitigation. A bottleneck is only a problem if it goes undetected and is able to rob your value stream of efficiency. Either a routine and systematic practice of manual inspection of value stream and workflow metrics or an automated monitor and alert system like that provided by HCL Accelerate are your best front-line weapons for fighting the bottleneck scourge. Once you’ve found the bottlenecks, you’ll likely find the tools for mitigating them are already in your software development toolkit.
Is a value stream stage a bottleneck because of long processing times? See if any aspects of the process that can be automated or streamlined.
Batching in one stage interrupting flow downstream? Consider smaller, more frequent batches or eliminating batching all together.
Are non-uniform workloads causing havoc in your value stream? Build some flexibility into your team’s skill set so resources can be re-allocated to help clear queues before they incur costs.
See you’ve got this! Knowing where, why, and when a bottleneck appears allows for effective efficiency saving mitigation practice. Let HCL Accelerate’s detection and alert system find the bottlenecks as they appear so your team can do what it does best; develop software in an efficient and effective value stream.