Blogs

Cycle Time Reduction - Beginner’s Guide to Reducing Cycle Times

Julian Colina
November 10, 2020
  • toc-h2
  • toc-h3
  • toc-h4
  • toc-active
What separates the best software teams from the rest of the pack?

Do they work more hours?

Have brilliant engineers?

The free cold brew keg in the office?

Nope. It's none of those things.

Rather, it's the speed and quality of their execution. Behind many of the notable teams (Google, Spotify, etc) lies a secret weapon: optimized Cycle Time.

"Cycle time compression may be the most underestimated force in determining winners and losers in tech."

- Marc Andreessen


What is Cycle Time?

In its simplest form, Cycle time can be calculated from the time of first commit to pull request merged. In other words, the speed of your development.

"Development" can be broken down into 2 distinct phases:

  1. Design Phase - work prior to writing code
  2. Delivery Phase - work to deliver value to the customer

At Haystack we focus on the delivery phase.

Unlike the design phase, engineering teams have full control over the delivery phase - making Cycle Time more appropriate than Lead Time when measuring and optimizing at the engineering level.

What are the benefits of Cycle Time?

From technical debt to context switching - there are about a thousand things that can affect an engineering team. They all impact Cycle Time. This makes Cycle Time a strong signal for when problems arise - giving teams a feedback loop for improvement.

Teams optimizing Cycle Time typically see:

1) Faster Delivery

Faster Cycle Times lead to faster delivery and enable teams to better support customer demand. Measuring Cycle Time makes it easier to improve current processes by identifying friction that causes long cycle times. Consistently working to improve workflows helps ship faster and have a healthier push to production cycle.

 

2) More Flexibility

‍Faster Cycle Times enable teams to be more efficient and flexible. This flexibility enables teams to cut down the expense of changing priorities and increase customer responsiveness.

 

3) Less Work In Progress (WIP)

In order to make cycle time improvement, teams are required to optimize their current process. In most cases, you’ll find that concurrent work and context switching drastically increases the total cycle time for each task. Teams naturally find themselves limiting WIP to improve speed.

 

4) Less Rework

Teams who optimize Cycle Time end up focusing on smaller, more manageable chunks of work. This makes code review faster, easier, and developers get feedback earlier in the process - allowing them to spend less time reworking code.

 

5) Less Defects

Since changes are kept small when optimizing Cycle Time, developers are less likely to make mistakes. This leads to less bugs in production and higher rates of customer satisfaction.

6) Improved Morale

When you can see how much time you're wasting on things like tech debt - all of a sudden that refactor we've been putting off starts to make a lot more sense. As we remove friction in our process we're improving the developer experience as well - leading to higher rates of engineering satisfaction and motivation.

Cycle Time helps dev teams deliver better code, faster, more flexibly, and ultimately leads to higher employee morale.

That's a win-win-win-win.

 

How To Reduce Cycle Time

Just about every developer, team, and company wants to ship faster, build better code, and deliver more value to customers. Cycle Time gives us a tool to do that.

By understanding their Cycle Time, dev teams can:

1) Baseline The Development Process

All factors from tech debt to context switching impact Cycle time. This gives us a benchmark to quickly spot outliers and investigate where problems may lie. To get a baseline, average together the cycle time from the past 6 months - giving you an average across a variety of tasks.

2) Identify Leaks & Clogs

Our baseline gives us a reference point to notice when one task is not like the others (aka longer cycle times). This often reveals common, fixable issues in our development process. This examination often reveals one of many common inefficiencies:

Common Inefficiencies:

Slow Code Review - Devs aren’t prioritizing code review or something is getting in their way.

Insufficient Deployment Tooling - Deployment is not as easy as it should be.

Long QA Process - QA checks may need to be optimized with automated testing.

Too Much 'Work In Progress' - Context switching slows the team down.

Large Batch Work - Developers work in large batches slowing down the process

3) Address Bottlenecks

We all have a backlog of improvements we would like to make. Cycle Time helps us identify and prioritize which bottlenecks are high priority. The next step is to meet with your team and come up with actionable solutions. These should be concrete steps taken to address the largest bottlenecks.

Here are some examples:

Focus on PR Response Time - Agree on a reasonable amount of time for a pull request to be waiting for a review. Typically we aim for 24 hour response time.

Build Deployment Automation - Build simple tools to help reduce the friction in deployment. This can be as simple as a github action that runs the test suite.

Build Testing Automation - Help reduce the friction in the QA process by creating automation. This can be writing unit tests for parts of the system that need the most manual testing.

Limit WIP - Context switching often slows the entire team down. Agree on a reasonable number of tasks to be ‘In Progress’ simultaneously.

Reduce Size of Work - Working in smaller batches helps reduce the friction at every stage in the process from implementation to deployment. Focus on working in small batches. 

 

4) Measure Impact

The inefficiencies above often go unnoticed, building up in the background. Cycle Time helps us reduce our own bias, replace our gut feelings, and quickly identify the sources of inefficiency. Now that we’ve made changes it’s time to sit back and see if our changes make a positive difference to Cycle Time.‍

Getting Started with Cycle Time

Cycle Time gives us insight into how our team works and where we get stuck. It's a feedback loop for improvement which allows us to ship quality code faster and improve the lives (and sanity) of developers. If you're interested in empowering your team to improve, reducing wait times, developing new processes, and removing bottlenecks - then we would urge you to start using Cycle Time.

 

Kickoff your cycle time reduction effort with a free trial of Haystack where we automatically monitor Cycle Time from your Github repositories.

 

Trust us, your team will thank you.

 

Haystack helps engineering leaders identify burnout and team health patterns. Instead of guessing if you're improving, or constantly bothering your team for updates, simply use Haystack to get alerts in your inbox every morning. Plus a dashboard to track improvements over time.

Try it for free



About the author

Julian Colina
CEO & Cofounder of Haystack.

Our latest news

Discover our latest articles, feature releases, and more!

Ready to get started?

Start Free Trial