# How To Improve Lead Time For Changes (aka Cycle Time) | LinearB Blog > Master Lead Time for Changes: learn how to identify bottlenecks, optimize cycle time, and boost software delivery efficiency with actionable steps. _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)._ [Blog](https://linearb.io/blog) / How To Improve Lead Time For Changes (aka Cycle Time) # How To Improve Lead Time For Changes (aka Cycle Time) ![Photo of Ben Lloyd Pearson](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/blp_headshot_1_ee25d527aa?_a=BAVMn6ID0) By [Ben Lloyd Pearson](https://linearb.io/blog/how-to-improve-lead-time-for-changes-cycle-time#ben-lloyd-pearson) | November 22, 2023 ![git_dashboard_e274ab9b10](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/git_dashboard_e274ab9b10?_a=BAVMn6ID0) ### _This guide is part of a course on_ [_How To Master DORA Metrics_](https://linearb.io/blog/how-to-master-dora-metrics)_. You can find the intro to the course as well as links to other modules_ [_here_](https://linearb.io/blog/how-to-master-dora-metrics)_._ In this module of the course, you’ll learn about the Lead Time for Changes DORA metric, what challenges commonly impact it, and how you and your team can help you overcome these issues. Key takeaways from this module include: * Lead Time for Changes represents the average duration from beginning a change to your code base to the time the change’s code is released to production. * Understanding your [cycle time](https://linearb.io/blog/cycle-time) is crucial to understanding — and improving — your Lead Time for Changes metrics. Composed of four-time stages ([coding time,](https://linearb.io/blog/reducing-coding-time) [pickup time](https://linearb.io/blog/pull-request-pickup-time), [review time](https://linearb.io/blog/reducing-pr-review-time), and [time to deploy](https://linearb.io/blog/cycle-time-breakdown-tactics-for-reducing-deploy-time)), cycle time helps you quantify the time an engineering task takes to move through production to deployment. * Causes of a poor Lead Time for Changes metric include development bottlenecks, a lack of automation, and poor communication, among other challenges. Using continuous merge, CI/CD pipelines, and scheduling regular retrospectives can mitigate these concerns. ## Introduction Lead Time for Changes refers to the average duration from beginning work on a code base change to releasing that change’s code to production. The majority of your lead time, and the most crucial phase of the software development and deployment process, is . Cycle time zooms in on the more quantifiable time for an engineering task to move from initial code commit to production deployment. Within cycle time, four discrete stages are critical to isolate and track individually: * **Coding time** — The time an individual contributor spends writing the necessary code to complete the engineering task * **Pickup time** — The time between opening a pull request (PR) and beginning code review * **Review time** — The time between the initial code review and a pull request being approved by the team and merged for release to production * **Time to deploy** — The time it takes from merging the code change to its release in production As software teams vary widely in the time they spend on each stage of cycle time, it’s important to gather discrete metrics for each stage to identify bottlenecks and areas for improvement in your delivery process. ## Understanding and optimizing cycle time Cycle time is the most critical aspect in tracking the delivery time of new software features and updates, measuring team efficiency, and improving the predictability of project timelines. Our [DORA Metrics dashboard](https://linearb.helpdocs.io/article/7ck7fu67am-metrics-dashboards-dora-metrics) lets you track the various stages of cycle time by interfacing with your version control system to display individual metrics for each phase. > "Cycle time is an engineering super metric" > > \- Ori Keren, co-founder and CEO of LinearB The ability to compare your team’s cycle time metrics with industry-standard [engineering benchmarks](https://linearb.io/resources/engineering-benchmarks) helps identify areas for improvement to your platform or processes. Optimizing the predictability of your team’s delivery and release times allows engineering and product leadership to create more accurate project timelines, establish realistic go-to-market expectations for stakeholders, and boost the morale of development teams by reducing the likelihood of delays and missed deadlines. ## Why you should care about Lead Time for Changes Lead time is the most vital metric to target when optimizing your team’s software development cycle. It is directly related to your business’ product delivery and go-to-market speed. A consistent and predictable lead time enables you to create accurate project timelines and keep your commitments to stakeholders. It also reflects your team’s efficiency and morale: Greater confidence in their ability to deliver on-time code changes leads to happier team members and reduces the likelihood of burnout. ## Common issues affecting Lead Time for Changes Let’s discuss some common issues that can impact your Lead Time for Changes metrics. ### Bottlenecks in the development pipeline Identifying bottlenecks in your development pipeline is the first step in improving software delivery efficiency. Bottlenecks to watch for include: * **Coding time** — If your team’s average coding time is higher than the industry norm, it could indicate an issue at the project management level, where tasks aren’t broken into sufficiently manageable work units. It could also indicate a lack of clarity in defining task requirements or a need to diversify your team’s collective skillsets, seniority, or specialization levels. * **Pickup time** — A high pickup time indicates a breakdown in communication within or between teams and can also indicate work overload. If developers have too many tasks in flight to begin reviewing each other’s code promptly, this will adversely affect pickup time and is a potential indicator of burnout. * **Slow code reviews** — If your team’s code reviews exceed the industry average, they might be struggling with poorly scoped project management tasks. They might encounter bloated, difficult-to-review pull requests or fail to identify the team member with the most applicable project or domain knowledge to review specific code base changes. * **Deployment delays** — A high average time to deploy could indicate bottlenecks in your testing/QA process or a lack of automation within your deployment approach. #### Inefficient processes or lack of automation The code pickup and review process are often two of the software development cycle’s most manual and inefficient phases. Once a pull request is opened, the code author must notify their teammates that it needs review. If they’re unsure about finding the most appropriate reviewer for their changes or their teammates are busy with other work, their pull request can sit in the pickup phase for quite some time. Code reviews can also cause delays when pull requests are too long or complex, or there is a failure to select the proper expert for the review. At the same time, smaller, safer changes can pile up in the queue. Such changes could have been merged quickly without the burden of context switching to another more involved review. #### Communication challenges within and between teams While communication about pull requests and review processes can create issues for teams, there is even greater inefficiency for cooperating teams working on different sprint cycles, deadlines, and meeting schedules. Without a system of [workflow automation](https://linearb.io/platform/workflow-automation) to standardize communications, messages can go unread, necessitating multiple follow-ups to get a pull request moved from pickup to review. #### Changing requirements Some degree of change concerning project requirements is inevitable in software development. However, constant and unpredictable change will lead to development inefficiency, frustration, and burnout within your teams. There’s a symbiotic relationship between lead time and change requirements, as teams with quicker lead times can adjust more agilely to necessary changes. Still, you need to balance change and stability to maintain faster lead times. ### Solutions to optimize cycle time The good news is that you can address these common issues by improving your team’s automation processes, increasing communication, and performing regular retrospectives. #### Use CI/CD and Continuous Merge Continuous integration/continuous delivery (CI/CD) and [continuous merge](https://linearb.io/blog/what-is-continuous-merge) help you streamline development processes. In continuous integration, you merge code into a source repository in an environment where you can configure automated tests and build phases to run consistently and reproducibly. Then, with continuous delivery, code is automatically pushed through various staging and production deployment environments up to its final release. Just as CI/CD automates as many components as possible in a software release’s development, testing, and deployment phases, streamlines the often manual and typically inefficient process of moving code through the pull request, review, and merge phases. Continuous merge works to resolve this issue by allowing code authors to provide context in the form of valuable metadata, such as [estimated time to review](https://linearb.helpdocs.io/article/7d9makf1og-worker-b-estimated-review-time), complexity of the code, and a request for expert reviews by indicating which section of the code base they’re working with. A continuous merge system can then prioritize code for review in the team’s queue so that less significant and lower-risk changes are merged more quickly, and the right team members get paired as reviewers on a pull request. These strategies reduce time spent on each engineering task in the pickup and review phases of your team’s cycle time and can be implemented seamlessly with [gitStream](https://linearb.io/platform/gitstream). You can use gitStream’s [programmable workflow](https://linearb.io/platform/programmable-workflows) features to improve your team’s code review process and optimize cycle time by creating automations to auto-merge [safe changes](https://docs.gitstream.cm/automations/approve-safe-changes/) and [small fixes](https://docs.gitstream.cm/automations/approve-tiny-changes/) and approve pull requests from [trusted teams](https://docs.gitstream.cm/automations/approve-team-by-directory/). #### Use engineering metrics benchmarks for targeted improvement With a metrics platform, you have up-to-the-minute access to your team’s performance level for the various stages of cycle time compared to industry competitors. With this insight into your , you can target specific phases of cycle time for improvement and increase your performance across cycle time as a whole. Improving your team’s pickup time positively affects review time, as longer pickup times for pull requests correlate directly with longer review times. You can use tools to reduce pickup and review time by adding estimated time to review labels to pull requests (PRs), assigning the right reviewer, and creating real-time alerts on a pull request's state. Tracking these metrics benchmarks also encourages your team to make smaller code changes in their PRs, a best practice in software delivery that results in demonstrable improvements across all DORA metrics. #### Streamline communication Another strategy for improving cycle time metrics is streamlining communications within and across teams. Use automation tools that integrate various aspects of your toolchain, such as your messaging and communications platforms. You can streamline communication with tools like Slack, Microsoft Teams, and similar collaboration solutions to support real-time check-ins. Additionally, you can schedule regular sync-ups to ensure that everyone on the team is up to date on current projects, project progress, and development hiccups. #### Schedule regular retrospectives Create a culture of continuous improvement by scheduling regular retrospectives. In these retrospectives, your team can work collaboratively to identify and address bottlenecks by analyzing past and present development practices. ## Practical steps to take action today Below are some steps you can take today to improve your cycle and lead times: * **Audit current development processes** to identify time-consuming steps. Search for areas where bottlenecks frequently appear and center efforts on mitigating those issues. * **Implement** [**workflow automations**](https://linearb.io/platform/workflow-automation) that target major bottlenecks. Once you’ve identified what needs attention, leverage automation tooling to ensure event-driven tasks are executed as soon as possible and prevent introducing human error during manual work. * **Gather metrics** and key performance indicators (KPIs) related to cycle time for data-driven improvements. Use these KPIs to help you identify what is — and isn’t — benefiting your cycle time. * Encourage a **culture of continuous improvement** within the team. ## Long-term benefits of reducing cycle time Identifying and addressing common issues and bottlenecks to reduce your team’s lead and cycle time produces numerous long-term benefits: * Increased customer satisfaction due to timely releases. * Enhanced team collaboration and reduced burnout. * Reduction in context switching with quicker reviews and less time spent on reviews. ### Lead time analytics with LinearB LinearB Metrics provides all the tools you need to accurately [track and calculate](https://linearb.helpdocs.io/article/0vif1ihmgc-how-is-cycle-time-calculated) your team’s cycle time through its project management and source code management integrations, letting you display, analyze, and compare this metric against industry benchmarks. ’s estimated time to review features help reduce pickup and review time overall. Additionally, WorkerB’s goal-setting and notification features improve software engineering efficiency at the individual contributor and team levels. To use LinearB to view historical data on each phase of your team’s [cycle time](https://linearb.helpdocs.io/article/v9pckvmkbj-cycle-time), refer to our DORA metrics dashboard [documentation](https://linearb.helpdocs.io/article/7ck7fu67am-metrics-dashboards-dora-metrics). ## Summary Now that we’ve explored the importance of tracking lead and cycle time and strategies for improving them, let’s turn to the next DORA metric: Change Failure Rate. As we work through these metrics, be sure to get [free DORA metrics](https://linearb.io/resources/free-dora-waitlist) to measure your organization against industry standards. Then, [use gitStream](https://linearb.io/platform/gitstream) to improve software engineering efficiency. ## Improve developer productivity with LinearB Find us on [](https://www.linkedin.com/company/linearb) [](https://devinterrupted.substack.com/) ![blp_headshot_1_ee25d527aa](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/blp_headshot_1_ee25d527aa?_a=BAVMn6ID0) ## Ben Lloyd Pearson Ben hosts Dev Interrupted, a podcast and newsletter for engineering leaders, and is Director of DevEx Strategy at LinearB. Ben has spent the last decade working in platform engineering and developer advocacy to help teams improve workflows, foster internal and external communities, and deliver better developer experiences. ### Connect with [](https://www.linkedin.com/in/benlloydpearson) [](https://substack.com/@benlloydpearson) ## Your next read [![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... [![Cover image for AI is rebuilding software delivery from SDLC to ADLC](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_rebuilding_software_delivery_2400x1256_3fd5887e75?_a=BAVMn6ID0)](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation) Eng. Metrics [AI is rebuilding software delivery from SDLC to ADLC](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation) Discover how engineering organizations are transitioning from the traditional SDLC to an Agentic Development Lifecycle (ADLC). Learn why rising token costs... [![Cover image for 8 million pull requests reveal where engineering productivity breaks down](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_8_million_pull_requests_2400x1256_03724bfbb2?_a=BAVMn6ID0)](https://linearb.io/blog/8-million-prs-engineering-productivity) Eng. Metrics [8 million pull requests reveal where engineering productivity breaks down](https://linearb.io/blog/8-million-prs-engineering-productivity) 8.1M pull requests reveal the gap between AI adoption and engineering impact, and why code review is the bottleneck blocking real productivity gains. ## 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": "How To Improve Lead Time For Changes (aka Cycle Time)", "url": "https://linearb.io/blog/how-to-improve-lead-time-for-changes-cycle-time", "author": { "@type": "Person", "name": "Ben Lloyd Pearson" }, "datePublished": "2023-11-22T16:09:31.406Z", "dateModified": "2023-11-22T16:09:31.406Z", "image": "https://assets.linearb.io/image/upload/v1720000000/git_dashboard_e274ab9b10.png", "publisher": { "@type": "Organization", "name": "LinearB", "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png" }, "description": "Master Lead Time for Changes: learn how to identify bottlenecks, optimize cycle time, and boost software delivery efficiency with actionable steps." } ``` ## 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) - [Register now](https://linearb.io/event/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 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)