Observe
Accelerate
Troubleshoot
The software industry is currently at an inflection point due to the avalanche of GenAI code output. Engineering organizations are facing unprecedented challenges in feedback cycle frequency and code volume and complexity, magnifying the potential for errors, unintended behaviors, and deployment risks.
To meet the challenges AI has introduced to modern software delivery, we need a new approach: toolchain observability.
What is toolchain observability?
Toolchain observability enables the capability to track, analyze, and optimize every stage of the software build, test, and deploy process. Traditional observability began as a way to visualize what happens in a system by recording logs, metrics, and tracing data. Develocity’s toolchain observability—Develocity 360— takes this further by shifting visibility left and extending it across your entire software delivery pipeline, from the developer’s local machine all the way to CI. By recording the end-to-end build process, regardless of your tech stack or toolchain, Develocity uncovers the full context and relationships between different parts of the software build process.
By capturing comprehensive data throughout the build process, development teams are empowered to detect the unknown unknowns so they can ship faster, reduce risk, and lower costs, all while maintaining the highest standards of quality and compliance.
Why now?
Modern software engineering is becoming increasingly sophisticated, relying on GenAI-driven code, distributed toolchains, hybrid cloud environments, and open-source dependencies. This growing complexity introduces productivity and performance challenges along with significant security and governance risks. Without deep visibility into their toolchains, organizations struggle to maintain continuous delivery best practices, diagnose CI/CD pipeline inefficiencies (and so manage CI costs), and ensure secure software governance.
A deeper solution: Develocity 360
To meet the growing demand for observability across both local and CI build processes, we’ve launched a new product offering for Develocity: Develocity 360. With the enhanced observability provided by Develocity 360, your organization can:
- Gain actionable insights for proactive troubleshooting and issue resolution
- Optimize build performance and compute resources
- Create a more reliable software delivery pipeline
- Ensure more secure and compliant software
Proactive troubleshooting and issue resolution
Unreliable builds decrease code quality and are a massive distraction from the developer workflow. Develocity Build Scan® pulls data from every build and test run—no more manually sifting through logs. With easy-to-use dashboards, you can track build and test failures, compare builds over time, identify dependency issues, and more, at both the individual and organizational levels.
“Dependency resolution between artifacts is really clear to us. We are better equipped to handle these issues because we don’t need to start from scratch—it used to take us up to 30 min to compare dependencies, but now we can just compare the latest build with the last successful build and immediately see which dependencies have changed.”
– Loïc Teikiteetini-Vaysse, Staff DevOps Engineer at Criteo
Develocity gives you the data to see which builds are failing and where issues are getting better or worse over time. By proactively identifying where and when failures are occurring, teams can invest in the right places, fix issues early before their impact grows, and ultimately reduce the time spent on troubleshooting downstream.
Develocity’s Agentic AI, allows developers to query the agent for immediate issue identification and solution recommendations—all directly from the IDE.
By collecting failure data from every build across every project and surfacing that data in multiple interfaces—through built-in dashboards, seamlessly integrated business intelligence/reporting tools, or directed AI prompts—development teams are empowered to solve issues rapidly as they arise and proactively improve build reliability over time.
Performance and resource optimization
If you have long CI queues, your instinct might be to throw more compute resources at it. But if you also knew that 90% of your CI cores were idle, you would instead look at parallelizing your builds. Develocity 360 ensures you identify the right issue and gives you the data you need to solve it.
With deep end-to-end observability into the build process, you can detect bottlenecks in CI/CD pipelines, optimize caching, reduce flakiness in automated tests, and much more.
- Get a variety of information on test performance. By analyzing test retries and comparing executions of tests across builds, Develocity 360 surfaces insights about test flakiness. Developers re-run builds they know have flaky tests since the build will often pass on the second or third try. Eliminating flakiness means you’re re-running fewer builds, saving developer time and compute resources.
- View metrics and trends for all local and CI build performance data. This data includes build times, user- and project-specific data, dependency resolution, and more. You can use this data in any number of ways—for example, to quantify the cost of unnecessarily slow builds or the value of shaving one minute off the average build time in total engineering hours/days.
- Get insights into where time is really being spent and what the bottlenecks are. By giving you visibility into how CI pipelines consume compute resources, Develocity [product name] helps you make smarter infrastructure decisions. Instead of over-provisioning machines or scaling compute blindly, teams can pinpoint where resources are underutilized, where bottlenecks occur, and where optimizations will have the greatest ROI.
Pipeline reliability
DORA’s research established that continuous delivery (CD) practices enable high-performing teams to deploy multiple times a day, with a low failure rate and a fast recovery time, leading to improved software delivery performance. In other words, DORA’s four key metrics are strong indicators of software delivery excellence. However, one of the challenges facing organizations that want to measure and improve their DORA metrics is fragmented DevOps tools, which lead to poor observability and insufficient integration. The recent influx of GenAI-created code has only exacerbated the problem.
Develocity solves this by integrating with leading build and testing frameworks, capturing uniquely detailed and semantically rich data. This integration provides significantly richer insights than those available through conventional console outputs or standard reports, enabling deeper observability and more effective software delivery optimization. But not only does it span all your CI tools, it also covers the local development pipeline, shifting observability left all the way to a developer’s local builds.
Knowing that organizations will have their own existing dashboards (for example, Prometheus or Grafana) of key metrics, Develocity-generated insights can directly feed these, as well as automated workflows like ticket creation and alerts. Develocity supports hybrid deployments (on-premises or SaaS), accommodating enterprise-specific data locality, security, and regulatory compliance requirements.
Monitoring and observability from Develocity 360 help identify performance bottlenecks, inefficiencies, and intermittent issues within the software delivery pipeline. By proactively identifying these issues, teams can bring down the percentage of deployments that fail in production—a key DORA metric— and even the amount of time it takes to recover from a failed deployment.
Secure and compliant software
Security and compliance are increasingly tied to how well organizations understand the components flowing through their pipelines. Develocity enhances this visibility by surfacing detailed dependency data—including versions, transitive dependencies, and changes over time—across both local and CI builds.
This deep observability enables teams to shift security and compliance checks left, catching issues like vulnerable libraries, license violations, or supply chain risks as early as a developer’s local build—long before they reach production. By identifying and addressing risks earlier in the development lifecycle, teams reduce the cost and complexity of remediation while maintaining a fast, secure delivery process.
With this level of end-to-end insight, organizations can strengthen their security posture and stay audit-ready without introducing friction into developer workflows.
Empowering software delivery excellence with Develocity 360
Develocity is a key enabler of software delivery excellence in today’s development landscape. Organizations that adopt a toolchain observability platform like Develocity 360 will accelerate feedback cycle time, reduce costs, simplify developer troubleshooting, and proactively address security and compliance pressures.
To make toolchain observability a core part of your engineering strategy and experience, contact us: