# Cycle Time Formulas for Your Software Group | LinearB Blog

> How do you calculate the cycle time formula? Review different cycles many teams have, how to measure them and how it impacts decisions.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Cycle Time Formulas for Your Software Group",
      "item": "https://linearb.io/blog/cycle-time-formula"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Cycle Time Formulas for Your Software Group

# Cycle Time Formulas for Your Software Group

![Photo of Taurai Mutimutema](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0)

By [Taurai Mutimutema](https://linearb.io/blog/cycle-time-formula#taurai-mutimutema)

|

December 27, 2021

![thisisengineering_raeng_Gz_Drm7_SYQ_0g_unsplash_f96d375995](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/thisisengineering_raeng_Gz_Drm7_SYQ_0g_unsplash_f96d375995?_a=BAVMn6ID0)

A cycle time formula helps software project managers and engineers reach a reasonable estimate for the duration it takes from the start to finish of a project. Software teams always have one project or more underway. Without generalizing too much, projects are how things get done and how developers can focus on their work.

When you take a step back, it’s easy to appreciate that projects are just a series of tasks. We often lay tasks end to end to achieve project objectives. These objectives can be entirely new products or just a few touch-ups to existing systems. Almost always, and in line with the CI/CD mantra, these tasks include deploying new features continuously.

This post explores the use of cycle time formulas to keep software engineers productive, not overwhelmed by overly ambitious cycle time estimates. The general assumption is that you’re fully aware of [cycle times](https://linearb.io/blog/cycle-time). However, we’ll start with a quick recap as we build out the logic behind the formulas discussed later.

## An Explanation of Cycle Time

Cycle time is the measure of how long a unit task lasts. A task’s cycle time can be a few minutes, a few weeks, or even a month. The time unit your company adopts depends on the complexity of the tasks you assign developers. Not so much how hard the tasks are, but the steps and hoops through which developers have to navigate.

Gigantic tasks often exhibit long cycle times because of multiple nodes along the path to completion. There are many strategies you can apply to [reduce cycle times](https://linearb.io/blog/how-to-reduce-cycle-time-in-software-delivery). As a best practice, keeping short cycle times has a positive effect on developers’ productivity. The smaller the chunks of tasks you line up, the better chances of completion within time budgets. The opposite would be a monumental task that seems insurmountable to even the most skilled programmers (which also leads to a lot of idle time).

![Net cycle time vs. gross cycle time](https://assets.linearb.io/uploads/Screen-Shot-2021-10-18-at-1.05.03-AM-1024x538.png)

_Net cycle time vs. gross cycle time_ 

Even when you set reasonable time budgets as cycle times for your project tasks, some moments will leak as idle time. Developers may either have to wait for team members to provide input or need to rest between completing tasks. It helps to account for this time to [calculate cycle time accurately](https://linearb.io/blog/how-to-calculate-cycle-time).

The final timestamp difference between the start and the finish of tasks represents _gross cycle time_. The _net cycle time_, which is the actual productivity time, represents the pure work effort’s duration. This means you must remove idle time. Otherwise, you won’t know how much a particular task costs (in time and effort) and plan accordingly for future task recurrence.

## A Simple Formula for Calculating Cycle Time

[The simplest formula for cycle time](https://linearb.io/blog/how-to-calculate-cycle-time) involves the previously discussed net productive time and its determined start and finish times.

![A simple cycle time formula](https://assets.linearb.io/uploads/Screen-Shot-2021-10-18-at-1.05.03-AM-1-1024x446.png)

_A simple cycle time formula_ 

The equation above applies to an entire project as much as it holds for just one task. Often, the number of tasks observed (our formula denominator) will be one. This leaves the cycle time equal to the net productive time spent by a project or task actor(s).

Deducing these times is often easy, regardless of the project management tool you use. That’s because every task activity is traceable down to a unit second. In fact, even if you’re using a spreadsheet grid to track projects, timestamps and simple functions should come in handy when calculating cycle time according to the formula above. That said, let’s examine what activities hint at the start and end of a cycle for you to measure cycle times accurately.

![good cycle starting points pull quote](https://assets.linearb.io/uploads/LinearB-1-1.png)

## Marking the Beginning of a Cycle

The assumption here is that you’re not holding a stopwatch every time a task starts, clicking each time any pauses (idle times) occur. It’s smarter to be on the lookout for specific events and activities during which you measure cycle time. Good cycle starting points mark divisions for activities that matter to your stakeholders. Specific to software development, a cycle time usually starts when a developer commits effort to a task. Also, it’s worth noting that the start of a cycle consequently brings an end to a task’s lead time.

### A User Story

User stories help make sense of the work achieved by developers. They answer the question, “would a user be able to do \[activity\] with the product?” You can measure how much is possible as action items that developers build toward. This is common in test-driven development methodologies. In that case, when you begin work on a user story, that’s an opportune moment to start measuring cycle time.

### A Feature Spec

Besides what the user deems important in the final system (user story), you ought to measure from the developer’s perspective as well. For this, you should have a feature specification document. This allows you to create and break down project goals into unit tasks for developers to tackle. This way, each task that moves from “planned” or your backlog list to “active” automatically gets a timestamp for you to start measuring its cycle time. Since we’re measuring time, every feature worked into a system can be that event you start measuring—hence signaling the start of a cycle time interval.

## Determining a Cycle’s End

The second timestamp to watch for, yet equally important, is the end to an activity’s cycle. This is an automated tracking process in popular project management tools—as every task sent to a complete pile will have been recorded already. Since tasks move across boards regularly, you should be clear on when a cycle ends. Marking the end of a cycle time means you have accepted the effort and outcomes of a task’s duration.

### A Roll to Production

Whether it be a user story or a specification task, it should roll into production at some point. However, there are processes in between (mostly testing) that you should include in the cycle. The inclusion of tests makes sense since every task will undergo the various test types you impose for quality assurance.

### Activating a Dark Launch

Launching darkly is a quick way of bringing new features or requested changes to the end user. To be exact, it involves shipping to a small segment of users. All in all, as a launch method, it implies that user stories are complete. The moment you hit the launch button (ship new features) is a great point to stop the cycle time counter.

Once you’ve established the start and finish points for tasks you want to monitor, plug their values into the cycle time equation. Realistically, as long as an event exists as a single entity in your project management system, you should be able to pull its cycle time.

![cycle time aids in decision making pull quote](https://assets.linearb.io/uploads/LinearB-2.png)

## Making Decisions From Cycle Time

All these considerations, and any you’re currently using to determine cycle time, are important only when they aid in decision-making. The first and obvious, use of cycle time after using that formula is setting schedules. If the client, or internal users, ever requests stories or features of the same weight, you should have a general delivery date estimate ready.

The second reason you’ll need cycle times has to do with[ improving your team’s delivery process](https://linearb.io/blog/cycle-time-measuring-and-improving-team-process). Measuring cycle time can reveal key improvement areas in every developer’s effort process. Not to say you should implement a “big brother” environment (it’s likely to have adverse effects). However, you can (must) address the reasons why developers take a long time on seemingly simple or previously measured cycles. The result is that you’ll consistently improve your software delivery process.

Lastly, cycle times will help you gauge the availability of your software team for new projects. Knowing how long you’ll wait before an ample number of developers are ready for projects reduces the lead time for any new tasks. Such decisions keep the end users/customers satisfied, and more importantly, it maintains good morale among your developer teams.

[![Improve your engineering organization at every level with LinearB](https://assets.linearb.io/uploads/GenericLineaRB3Pillars-1024x497.png)](https://linearb.io/get-started/)

Want to improve your engineering processes at every level? [Get started with a LinearB free-forever account today!](https://linearb.io/get-started)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

## Your next read

[![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Eng. Metrics

[Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption...

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

Eng. Metrics

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

[![Cover image for AI ROI comes from measuring engineering outcomes on day one](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_ROI_comes_from_measuring_engineering_software_security_2400x1256_2c5eae0862?_a=BAVMn6ID0)](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Eng. Metrics

[AI ROI comes from measuring engineering outcomes on day one](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Kraken Engineering Operations Lead Nik Sudan details how to establish day-one data infrastructure to accurately measure AI ROI. Discover why raw token adoption...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Cycle Time Formulas for Your Software Group",
  "url": "https://linearb.io/blog/cycle-time-formula",
  "author": {
    "@type": "Person",
    "name": "Taurai Mutimutema"
  },
  "datePublished": "2021-12-27T09:00:00.000Z",
  "dateModified": "2021-12-27T09:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/thisisengineering_raeng_Gz_Drm7_SYQ_0g_unsplash_f96d375995.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "How do you calculate the cycle time formula? Review different cycles many teams have, how to measure them and how it impacts decisions.\n"
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)