Building culture with cycle times

Engineering Metrics

Oct 23, 2023

In the realm of software engineering, the term "cycle time" often surfaces in discussions about optimization, team performance, and engineering productivity. But beyond its technical implications, cycle time plays a pivotal role in shaping the culture of an engineering team. Let's delve into how cycle time can be a cornerstone in building a robust engineering culture and why it's more than just a metric.

Understanding Cycle Time

Cycle time, in the context of software development, refers to the duration it takes for a piece of work, like a feature or bug fix, to move from the start of the development process to its completion. It encompasses everything from the initial code writing, code review, testing, and finally, deployment.

The Cultural Impact of Cycle Time

  • Transparency and Trust: A consistent and optimized cycle time fosters transparency. When team members and stakeholders can predict how long tasks will take, it builds trust. Trust, in turn, is the bedrock of a healthy engineering organization culture.

  • Collaboration and Team Performance: Monitoring cycle time encourages collaboration. Team members become more aware of bottlenecks and are more inclined to work together to address them, enhancing overall team performance.

  • Feedback and Continuous Improvement: Shorter cycle times mean quicker feedback. Rapid feedback loops are crucial for continuous improvement, allowing the engineering team to adapt and refine their workflow.

  • Empowerment and Autonomy: By focusing on reducing cycle time, team members are often empowered to make decisions that streamline the development process. This sense of autonomy can boost morale and job satisfaction.

Harnessing Engineering Metrics to Optimize Cycle Time

  • Dashboards and KPIs: Utilize dashboards to visualize cycle time and other related KPIs. This provides a clear picture of where the team stands and which areas need attention.

  • Code Review Process: Regular and efficient code reviews can significantly reduce cycle time. It ensures that code quality is maintained, reducing the need for rework.

  • Automation: Implementing automation in testing and deployment can drastically cut down cycle times. It not only speeds up the process but also reduces the chances of human error.

  • Addressing Bottlenecks: Identify and address bottlenecks in the engineering process. Whether it's a particular step in the workflow or allocation of resources, addressing these bottlenecks can lead to a more streamlined process.

BuildPulse: Your Partner in Optimizing Cycle Time

BuildPulse Engineering Metrics is an invaluable tool for teams aiming to optimize their cycle times. It not only provides insights into metrics like lead time, lines of code, and pull requests but also acts as a developer copilot. With features that notify about stale pull requests and automate reviews, it ensures that the engineering process remains smooth and efficient.

Moreover, with BuildPulse, engineering leaders can set benchmarks, measure productivity, and ensure that the team's initiatives align with business goals. It's not just about reducing cycle time; it's about ensuring that the entire software development process is as efficient and productive as possible.

In Conclusion

Cycle time is more than just a metric in the world of software engineering. It's a reflection of the culture, values, and practices of an engineering team. By focusing on optimizing cycle time, teams can not only improve their performance but also foster a culture of transparency, collaboration, and continuous improvement.

In today's fast-paced development landscape, where delivering new features on time is crucial, having a tool like BuildPulse can be a game-changer. It ensures that the team remains on track, and the development process is as streamlined as possible.


What is the difference between a flaky test and a false positive?

A false positive is a test failure in your test suite due to an actual error in the code being executed, or a mismatch in what the test expects from the code.

A flaky test is when you have conflicting test results for the same code. For example, while running tests if you see that a test fails and passes, but the code hasn’t changed, then it’s a flaky test. There’s many causes of flakiness.

What is an example of a flaky test?

An example can be seen in growing test suites - when pull request builds fail for changes you haven’t made. Put differently, when you see a test pass and fail without any code change. These failed tests are flaky tests.

What are common causes of flakiness?

Broken assumptions in test automation and development process can introduce flaky tests - for example, if test data is shared between different tests whether asynchronous, high concurrency, or sequential, the results of one test can affect another. 

Poorly written test code can also be a factor. Improper polling, race conditions, improper event dependency handling, shared test data, or timeout handling for network requests or page loads. Any of these can lead to flaky test failures and test flakiness.

End-to-end tests that rely on internal API uptime can cause test flakiness and test failures.

What's the impact of flaky tests?

Flaky tests can wreck havoc on the development process - from wasted developer time from test retries, to creating bugs and product instability and missed releases, time-consuming flaky tests can grind your development process to a halt.

What is the best way to resolve or fix flaky tests?

Devops, software engineering, and software development teams will often need to compare code changes, logs, and other context across test environments from before the test instability started, and after - adding retries or reruns can also help with debugging. Test detection and test execution tooling can help automate this process as well. 

BuildPulse enables you to find, assess impact metrics, quarantine, and fix flaky tests.

What are some strategies for preventing flaky tests?

Paying attention and prioritizing flaky tests as they come up can be a good way to prevent them from becoming an issue. This is where a testing culture is important - if a flaky test case is spotted by an engineer, it should be logged right away. This, however, takes a certain level of hygiene - BuildPulse can provide monitoring so flaky tests are caught right away.

What type of tests have flaky tests?

Flaky tests can be seen across the testing process - unit tests, integration tests, end-to-end tests, UI tests, acceptance tests.

What if I don't have that many flaky tests?

Flaky tests can be stealthy - often ignored by engineers and test runs are retried, they build up until they can’t be ignored anymore. These automated tests slow down developer productivity, impact functionality, and reduce confidence in test results and test suites. Better to get ahead while it’s easy and invest in test management.

It’s also important to prevent regressions to catch flakiness early while it’s manageable.

What languages and continuous integration providers does BuildPulse work with?

BuildPulse integrates with all continuous integration providers (including GitHub Actions, BitBucket Pipelines, and more), test frameworks, and workflows.

Combat non-determinism, drive test confidence, and provide the best experience you can to your developers!

How long does implementation/integration with BuildPulse take?

Implementation/integration takes 5 minutes!

Ready for Takeoff?

Ready for Takeoff?

Ready for Takeoff?