One of the most important metrics we use to evaluate and optimize workflow efficiency is Cycle Time. In this article, we’ll dive into what Cycle Time is, how it breaks down into smaller components, and how you can leverage it to drive improvements in your team’s productivity.
What is Cycle Time?
Cycle Time is the total time it takes from the moment work begins on a task until it is deployed to production. It’s influenced by various stages in the software development lifecycle (SDLC), which is why breaking it down is essential for a proper analysis.
In general, the goal is always to achieve the lowest possible Cycle Time. This increases throughput—essentially, the rate at which work flows from start to finish.
It’s also worth mentioning that Cycle Time is one of the four DORA metrics, further emphasizing its importance. Since it’s widely adopted, it also allows you to benchmark your performance against industry standards.
Components of Cycle Time
Cycle Time is divided into several key phases, each representing a distinct stage in the lifecycle of a development task:
Coding Time: The time it takes from starting development on a task until the code is ready for review (i.e., a pull request is marked as ready for review).
Pickup Time: The time between the code being ready for review and a reviewer beginning to review it.
Review Time: The duration from the start of the review until the code is approved.
Merge Time: The time from code approval to when it is merged into the main branch.
Deploy Time: The time from merging the code into the main branch to when it is deployed to production.
Interpreting and Improving Cycle Time
While lowering Cycle Time is important, it’s equally critical to aim for consistency. This means striving for tasks to take a similar amount of time to complete.
Why does a low and consistent Cycle Time matter? Think of software development as a production chain. For the chain to be efficient, we need to minimize inventory (unfinished tasks) and ensure tasks move smoothly from one stage to the next without unnecessary delays. If either of these goals isn’t met, it not only slows down the specific task but also creates bottlenecks that delay the entire workflow.
Identifying Bottlenecks
Breaking down Cycle Time into its subcycles helps pinpoint exactly where bottlenecks are occurring in your development process. For example, if Review Time is consistently high, it might indicate issues with how reviews are assigned or the review process itself.
Among the five subcycles, Coding Time and Review Time are where most of the effort should be focused. While we aim to keep these within a controlled range, the other three subcycles—Pickup Time, Merge Time, and Deploy Time—should ideally be as close to zero as possible. These represent key opportunities for optimization and are often the easiest areas to address for quick wins in productivity.
How is Cycle Time Calculated?
Each subcycle has specific events that trigger its start and end. Let’s review them one by one:
Coding Time: Starts when a task is moved to “In Progress” or when the first commit is made—whichever comes first, to capture the earliest start point.
Transition to Pickup Time: There are three potential events to mark the end of Coding Time and the start of Pickup Time:
The pull request is marked as Ready for Review.
A reviewer is assigned to the pull request.
The task moves to a Reviewing state.
Pickup Time: Ends with the first review event, which starts the Review Time.
Review Time: Ends when the review process is completed. This can be determined by one of three events:
The pull request receives its final approval.
The pull request receives its first approval.
The final review is completed.
The default priority for these events is listed here, but it can be customized in the Organization Settings.
Merge Time: Starts after the review process ends and ends when the pull request is merged into the main branch.
Deploy Time: Begins when the code is merged into the main branch and ends when the code is deployed to production.
To make Deploy Time more precise and include pipeline durations that bring the code to a production-ready state, you can also use a Teambit API endpoint.
Conclusion
Cycle Time is a powerful metric for understanding and improving the efficiency of your development workflow. By breaking it down into its components and analyzing each phase, you can identify specific areas to optimize, accelerate your software delivery process, and boost your team’s overall productivity.
At Teambit, we’re here to help you get the most out of your productivity metrics. Use Cycle Time to detect and eliminate bottlenecks, and watch your team consistently deliver faster and better results.