Conference: Developer Productivity Engineering Summit – November 2-3, 2022. Early Birds learn more and register here!
Build Engineering Challenges and Pain Points
Your biggest challenge is managing the build process with frequent understaffing. This problem only exacerbates these additional challenges and pains:
Spending too much time responding to developer support requests to help diagnose and fix build failures (i.e., becoming the build help desk) without an easy way to collaborate when necessary or anticipate and prevent problems before they happen
Operating without data to determine who is responsible and accountable for problems (e.g., verification versus non-verification failures) and the inability to reproduce problems without a durable record of every build
Balancing competing goals of maintaining a stable build pipeline with the need to accommodate changes to code or build technology
Gradle Enterprise provides analytics for every build that can be aggregated to determine average build time savings from the use of Gradle Enterprise acceleration technologies. These time savings, which are typically in the range of 50-90%, can be easily translated into hard developer cost savings. This and other ROI contributions can be modeled and tracked using our online calculator. This, in turn, can be used to build a business case for DPE or justify on-going investment in your DPE initiative or PMO. The following Gradle Enterprise solution capabilities represent the key technology/automation enablers for your developer productivity initiative success.
A Build Scan can significantly reduce the amount of time build engineers spend responding to developer support requests to help troubleshoot and fix build failures. They do this by giving developers deep data for every build, so they can quickly find the root cause and fix their own problems without the need to dig through a variety of raw data sources or re-run broken builds to reproduce problems. When help from your team is required, collaborating with the dev teams on fixes is as easy as sharing a Build Scan link.
In combination with Failure Analytics (described next), Gradle Enterprise customers report reducing troubleshooting (MTTR) time on average by two-thirds. Further, by making build problems less painful to solve, the build team can achieve a more optimal and less conservative balance between pipeline stability and developer happiness by accommodating changes to code or build technology more readily and with more confidence.
Build and Test Failure Analytics leverage data to proactively find unreliable builds and tests, learn how many people and environments are affected by problems (like flaky tests), share information about them, and understand the root cause efficiently. Specifically, Failure Analytics can quickly determine if a failure is the result of non-verification errors that require build engineering team intervention (e.g., network, infrastructure and repository failures, out-of-memory exception, or bugs in build logic) or verification errors which are coding errors that developers must fix. Quick and reliable data on who is responsible for fixes gives developers more confidence in the build engineering support processes and this encourages a culture of accountability and responsible developer behavior. It also ensures that build engineers are not made the scapegoats for problems they did not create.
Traditionally the responsibility of a build engineer was to create and pass on artifacts from development to production. More and more the focus is now shifting to improving developer productivity and enabling fast and frequent shipping of software. Gradle Enterprise Performance Acceleration technologies (including Build Cache, Predictive Test Selection, Test Distribution and Performance Continuity) help with this transition by addressing the pain of unnecessary developer idle time waiting for local and CI builds and tests to complete. Typical Gradle Enterprise customers cut build & test times 50-90% using just one of these technologies. This directly correlates with shipping quality code faster and more frequently.
Trends & Insights
How builds behave on local machines is usually a black box. Trends & Insights enable build engineers to take a proactive posture by providing performance and reliability baselines and observability of anomalous build behaviors and trends. With these insights build engineering can respond proactively to systemic near-term problems and longer-term performance regressions rather than being complaint driven. Moreover, Trends & Insights that you can monitor and act on, provide the foundation for building an always-learning and continuously improving software engineering culture. At the same time, improvements you make to local and CI build performance using acceleration technologies, despite the relentless growth of your code base, can be used to prove your value and make the case for additional resources.
- How many local and CI builds are run every day?
- How often do builds fail?
- What are the most common reasons for build failures?
- What are the most frequently executed tasks?
- What are the longest running tasks?
- Do builds behave differently by team location and for those working from home?
- How good is the incrementality and cacheability of the build?
- How often and when is the build unreliable?
- Are developers using development tools effectively?
- What is the economic benefit of investing in certain improvements?