How to Calculate Cycle Time in Software Development

Streamline your software development process and ensure that your projects are completed on time with our 2024 guide.

The Jit Team
By The Jit Team
Jit Logo
Edited by Jit Team

Updated March 5, 2024.

a purple background with the words how to calculate cycle time in software development

In recent years, the demands from software development teams have sounded more and more like the lyrics to an old Daft Punk song. Stakeholders demand code that is harder (in complexity), better (in performance), faster (in delivery), and stronger (in security). 

It’s no wonder that developers are stressed and burning out.

In one survey, 39% of developers cited increasing workloads and demands from other teams as the top contributing causes for burnout. The same study also found that 10% percent of developers saw repetitive tasks as the main reason for stress and burnout. As that catchy song goes—more than ever, hour after hour, work is never over.

But how do you measure “work” and those “hour after hour” coding sessions in the context of software development? That is where cycle time comes in.

Tweet about lack of productivity

What Is Cycle Time?

Cycle time is a metric that measures development speed from when work on a coding task begins to when it’s been delivered, deployed to production, and made available to users.

Lean Manufacturing defines this time as a velocity metric that focuses on calculating the performance of development teams rather than product managers, customer account managers, or decision makers assigning the development tasks.

» Explore DevOps continuous security solutions for improved workflow

Why Calculate Cycle Time?

Tracking time throughout the SDLC motivates teams to focus on improving and streamlining processes. This prevents both the submission and pulling of large code chunks for review. 

In addition, it can serve as a benchmark for comparison against the performance of developer teams worldwide.

» Find out what SSDLC is and why it matters

Cycle Time Averages

Cycle Time Calculation in Software Development Formula

To estimate the time it takes to complete a software development cycle, you can use the formula:

Cycle Time = Release Time – First Commit Time

However, it's also helpful to break the process down into phases and calculate the total duration of each stage to get a more accurate estimation of the cycle time

Cycle Time split into phases

  • Coding Time: The time between the first commit to a given branch and when a pull request is created for that branch.
  • Pickup Time: The time elapsed between when a pull request is issued and when the first comment is made on a pull request, thus indicating that code review was initiated.
  • Review Time: The span between the initiation of review (usually indicated by the first reviewer changing the PR state to “In review”) and the merge of a PR.
  • Deploy Time: The time between merging the PR and the code deployed to production.

Velocity Metrics and KPIs in Software Development

As a development team leader, one of your roles is to increase Velocity (without causing burnout) by continuously improving how your team gets things done. Before you can improve on something, you need to measure it as accurately as possible. For this, you need to select the most relevant metrics. 

‍The two most common metrics for calculation and optimization in software development are lead time and cycle time.

Lead Time vs Cycle Time

Lead Time & Lead Time for Changes

Lead time is a term borrowed from a manufacturing method by Toyota, and it measures the time between a customer placing an order and the time the customer receives the order. 

In software engineering, instead of Lead Time, the Velocity metric is often used as a measure of speed for DevOps processes.


Lead Time for Changes measures the time it takes to implement, test, and deliver changes to a software product's codebase.

Instead of starting the clock when a client (internal or external to the organization) places an order or assigns a task, Lead Time for Changes measures the time between the first code commit in a task and its deployment in production. 

» Improve the performance of your DevOps team with DORA metrics

Advantages of Cycle Time Calculation

A Holistic Metric for Engineers

You’ll likely have metrics and KPIs to measure how long tasks take to get done, and you’re working on optimizing those metrics. However, focusing on indicators like lead time gives you a partial picture and a limited view of potential bottlenecks.

The main advantage of cycle time calculation is the holistic but specific view of your SDLC, which measures the engineering process rather than product outcomes.

Actionable and Insightful

Cycle time calculations help you pinpoint the problematic areas and bottlenecks that may need your attention. By looking at the big picture, you can drill down into specific parts of the process and see where to introduce changes or improvements.

For example, you may notice that work slows during the review phase, which may be caused by a shortage of developer-first code security tools or a dire need for more automated testing solutions in your CI/CD pipeline.

Consistency and Scoping

It's frustrating when deadlines are missed, and you must rely on guesswork to estimate the time needed to complete a coding task, especially when reporting to top-level executives. Collecting data and optimizing cycle time can provide reliable estimates based on the data you collect., not just guesswork.

SDLC Life Cycle

Challenges of Cycle Time Measurement

While it is a useful metric for software development leaders, it should not be solely relied upon, as it may not always be perfect. Its main drawbacks are related to its benefits—it provides a comprehensive view of the software development process. These are:

Not Tracking Individual Performance

Cycle time regards software development as a team effort. Whether one developer did most of the work or was effectively divided - the metric focuses on how long it took the team to complete the task and merge the code into production.

Therefore, its measurement won’t help you pinpoint the issue if the bottleneck in your SDLC is not a process but an individual.

Not Considering Quality

Software development management is often a delicate balance between speed and quality. Cycle time will give you a good indication of development speed but won’t help you with code quality. Ideally, you should pair your cycle time with other DORA metrics that measure code quality and reliability, like change failure rate.


Since we’re talking about velocity and speed, it’s worth noting that cycle time is a lagging indicator and cannot serve you as an “early warning” system for SDLC bottlenecks. It will take quite a while before your cycle time calculations indicate an issue, so this metric will not grant you instant visibility into your development velocity and the bottlenecks holding it back.

» What's next? Here's how to correctly calculate the Change Failure Rate

Release Cycle Web Comic

Reducing cycle time with automation

Shorter cycle times often require a combination of organizational developer culture and intelligent tools that enable automation. With time, most software engineers will realize the benefits of smaller pull requests and efficient review processes. They require tools to automate repetitive tasks so that they can focus on their core skill of writing code.

Similar to how modern engineering organizations rely on metrics to consistently improve and optimize software delivery and velocity—security needs to instill similar metrics.

Jit is leading a new way of thinking about security metrics as they apply to mean time to remediate and change the failure rate of introducing security vulnerabilities. We believe this approach to security metrics will deliver the same benefits in the security world as in the software delivery and DevOps world.