Gradle Enterprise is now Develocity. Learn more about our rebrand here.
Management Team Challenges and Pain Points
The key success factors for achieving your key goals and addressing your key business drivers can be advanced with the launch of a Developer Productivity Engineering (DPE) initiative. Specifically, DPE addresses many of the dark costs that organizations continue to experience that are not accounted for by DevOps and that lie in the process of developing the software itself.
This includes a tremendous amount of unnecessary waste that can be directly linked to delays in receiving feedback, including unproductive build and test wait times, frustrating and slow paired debugging, and avoidable context-switching. This not only exhausts engineering resources but it also has a severe negative impact on developer creative flow, the agility of the development process, and developer morale. Even moderate delays in receiving feedback have a sizable effect on overall productivity.
Like DevOps, DPE takes a technology/automation approach to improving developer productivity and the developer experience. This contrasts with viewing productivity as a “people problem” that can be addressed using only management best practices. As a direct result of taking the DPE approach, you can overcome the following challenges and pain points that are pervasive in development organizations.
Winning the war for talent by solving issues that impact recruiting and retention. Devs want to code and be productive and not deal with unreliable tooling, unnecessarily long build and test feedback cycles, and inefficient troubleshooting.
Managing the growth of everything (e.g., number of devs, apps/modules, repositories, etc.). Your job is only getting more complex and flying blind is no longer an option. You need instant feedback and observability of performance, failures, other KPIs, and longer-term trends.
Improving confidence and predictability of software delivery timelines, quality, and cost. This can only be achieved with data-driven insights and better analytics on build and test pipeline bottlenecks like debug, build, and test cycle times.
Enabling team agility by supporting and incentivizing the right behaviors (e.g., reducing developer feedback cycles means developers build earlier and more often locally rather than on CI) and encouraging a culture of collaboration, accountability, and continuous professional development.
Develocity provides analytics for every build and test run that can be aggregated to determine average time savings from the use of Develocity 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 Develocity solution capabilities represent the key technology/automation enablers for your developer productivity initiative success.
Develocity Performance Acceleration technologies (including Build Cache, Predictive Test Selection, Test Distribution and Performance Continuity) address the pain of unnecessary developer idle time waiting for local and CI builds and tests to complete. They enable you to drive happier and more productive developers from the top down with faster feedback cycles that keep developers in the creative flow and minimize wait time and context switching. Typical Develocity customers cut build & test times 50-90% using just one of these technologies. As a result, in addition to productivity advantages for developers, CI engineers see more efficient use of resources and reduced cost of operating your hosted or on-premise CI/CD infrastructure.
The Build Scan service gives developers deep data for every build, so they can quickly find the root cause and fix their own problems without re-running broken builds to reproduce problems or requiring the help of your DPE/build team. When help from the DPE or build 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), Develocity customers report reducing troubleshooting (MTTR) time on average by two-thirds.
Unreliable builds cause downtime, waste compute resources and are a massive distraction. They also negatively affect the quality of the code that is shipped. Builds become unreliable when problems are too expensive to find, too hard to reproduce, and when fixes cannot be correctly prioritized because their relative impact is unknown.
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. As a result, developers have confidence in the build logic and test suites which encourages a culture of accountability and good behavior.
Finally, if you decide to stand up a dedicated DPE function or PMO (which is highly recommended), this is an ideal place organizationally to use Develocity to aggregate the outcomes of builds and tests across your organization. Your productivity engineers can then swiftly isolate bottlenecks and proactively cascade actionable tactics back to developers. Developers can also discover these on their own by accessing a shared central dashboard.
Trends & Insights
Trends & Insights enable your DPE function or PMO to observe build and test performance and reliability baselines and anomalous trends. With these insights your team can respond proactively to systemic problems and longer-term performance regressions rather than being complaint driven. Trends & Insights, combined with a dedicated team or DPE PMO to monitor and act on them, provides the foundation for building an always-learning and continuously improving software engineering culture.
Example alignment between your key drivers, C-level objectives and typical developer/build engineer pain points directly addressed by Develocity.