Achieving your Continuous Delivery and DORA goals with Develocity

Google Cloud’s DORA initiative is “the largest and longest running research program of its kind, that seeks to understand the capabilities that drive software delivery and operations performance. DORA helps teams apply those capabilities, leading to better organizational performance.”

DORA’s research outlines a set of evidence-based capabilities that lead to better organizational performance. DORA has clearly defined metrics—“the four keys”—that help your organization effectively measure the outcomes of your software delivery process and serve as predictors of better organizational performance and team member well-being:

• The time between code commit and deployment
• The frequency of deployments
• The percentage of deployments that fail in production
• The time it takes to recover from a failed deployment

DORA’s research found that continuous delivery (CD) is a key predictor of elite performance, as measured by the “four keys”. Continuous delivery 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.

This blog explores how Develocity helps you adopt and improve DORA capabilities, including continuous delivery, in order to achieve software delivery excellence in your organization. DORA’s 29 capabilities are split into three categories:

• Capabilities that enable a Climate for Learning
• Capabilities that enable Fast Flow
• Capabilities that enable Fast Feedback

We’ve broken these up—with a focus on Fast Flow and Fast Feedback—and grouped them in a way that maps naturally to the parts of the enterprise that have an impact on these capabilities. These six practices in particular directly improve your organization’s DORA capabilities:

1. Enabling smaller batch sizes and frequent, safe releases
2. Accelerating local developer loops in addition to CI loops
3. Deep observability and data-driven improvement
4. Continuous governance, risk, and compliance through automation
5. Enhanced operational layer across all toolchains
6. Driving the shift from CI to Platform Engineering

1. Enabling smaller batch sizes and frequent, safe releases

Working in small batches is a core DORA capability that leads to fast flow, and test automation and CI are continuous delivery practices that help enable frequent, safe releases. Implementing these capabilities enables fast flow and fast feedback, which, in turn, can improve DORA’s four key metrics.

However, the overhead in building and testing locally and on CI still discourages making small, frequent commits. This causes teams to accumulate changes, which in turn increases complexity and risk. GenAI will dramatically increase this problem, as more code leads to more builds and longer tests.

Develocity’s acceleration technologies directly address this by significantly reducing the overhead associated with builds and testing, eliminating the “penalty” of increased transactions traditionally associated with small-batch development.

Strategic outcomes:

• Adopt smaller batches: Faster feedback cycles lead to smaller batches and CD practices, like continuous testing
• More frequent deployments: Due to reduced merge conflicts and less code divergence
• Improved deployment quality: Cultural shifts at major tech companies like Netflix, Spotify, and Revolut show a positive correlation between the frequency of deployments and the deployment quality

2. Accelerating local developer loops in addition to CI loops

“Every minute chiseled off the build time is a minute saved for each developer every time they commit. [Especially with] Continuous Integration [which] demands frequent commits, this adds up to a lot of the time.”

– Martin Fowler (source)

Fast feedback and fast flow are crucial for improving the DORA metrics for both throughput and stability. Slow developer feedback loops ultimately result in slower release cycles—rapid feedback is a key enabler of delivering smaller code batches safely and more frequently. Many organizations focus on optimizing their CI/CD pipelines in order to improve the speed at which high-quality code can be put into production. This is because improving the CI/CD pipelines will improve the experience for all developers, and the performance of the CI/CD pipelines is more observable and therefore easier to improve.

However, the local developer experience is at least as important as the performance of shared environments like CI, and achieving fast feedback and fast flow at the local level will not only improve the speed at which code can be built, tested, and deployed but also improve developers’ well-being. Why? Because faster feedback loops reduce frustration and cognitive fatigue from frequent context switching.

Develocity’s acceleration capabilities—notably caching and distributed testing—equally benefit developers building locally and in centralized CI environments. Enhancing typical CI tools, Develocity shifts observability left and accelerates CI systems and local development environments, ensuring fast builds, reliable tests, and efficient teams.

Strategic outcomes:

• Rapid feedback loops: Encourage developers to execute builds and tests more frequently
• Reduced troubleshooting overhead: Via early identification of issues before they reach CI environments
• Improved performance consistency: Ensuring rapid feedback cycles regardless of build environment or toolchain

3. Deep observability and data-driven improvement

One of the challenges facing organizations that want to measure and improve their DORA metrics is fragmented DevOps tools, which leads to poor observability and not enough integration.

“Without integrated DevOps toolchains, digital businesses struggle to deliver customer value faster and to scale DevOps initiatives.”

– Gartner (source)

Develocity provides observability across the entire software delivery lifecycle. Develocity adds a layer on top of traditional CI and log-based solutions—where builds and tests are typically treated as generic processes—by deeply 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.

Develocity goes even further. Not only does it span all your CI tools, but it also includes the local development pipeline, shifting observability left. DORA metrics are traditionally measured from the time of code commit to when the code is active in production because most organizations lack visibility of what’s happening in a developer’s local environment. Develocity fills this gap and enables observability all the way to a developer’s local builds.

Monitoring and observability from Develocity 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.

Knowing that organizations will have their own existing dashboards (for example, Prometheus, 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.

Strategic outcomes:

• Visibility of inefficiencies: Allowing teams to identify, prioritize, and resolve productivity issues
• Optimized local pipelines: Helps teams actively refine and optimize their build/test pipelines
• Integrated delivery performance: Organizable insights and OKRs that directly contribute to DORA metrics

4. Continuous GRC (Governance, Risk, and Compliance) through automation

Security is no longer optional for enterprises—it’s essential. It safeguards brand reputation, protects revenue, ensures legal compliance, keeps operations running, and protects the software you deliver. As cyber threats grow, systems become more complex, and expectations from regulators, customers, and investors continue to rise, strong security is now a fundamental requirement for doing business.

The rise of Generative AI also brings dual challenges: it lowers the barrier for attackers to launch sophisticated threats, and if used within your organization, it may make your code harder to understand, audit, and secure.

DORA research shows that “high-performing teams spend 50 percent less time remediating security issues than low-performing teams”. They achieve this by fully automating and integrating GRC into the software delivery lifecycle via pervasive security.

Develocity’s capability to automate security and compliance protocols, a recommended continuous delivery practice, ensures governance is shifted left without sacrificing speed. Immutable Build Scan® data provides detailed records of every build and test execution, including build, test, first and third-party library dependencies, code coverage, test outcomes, and artifact provenance. Audit trails via Build Scan ensure that quality and regulatory requirements are systematically enforced.

Develocity enables enterprises—particularly those in regulated industries such as finance, healthcare, and government—to simultaneously enhance their delivery speed and achieve DORA’s definition of pervasive security.

Strategic outcomes:

• Automated policy enforcement (via OPA or scripts): Proactively prevents compliance violations in deployment
• Early detection of policy violations: Identifies outdated, vulnerable, or non-compliant software components for immediate resolution
• Direct integration with compliance dashboards: Helps ensure all regulatory standards are continuously and transparently met

5. Enhanced operational layer across all toolchains

The reality of software development in enterprises is a huge mix of tools and technologies that have been selected over time by different teams with different requirements. DORA research demonstrates that empowering teams to choose tools increases developer satisfaction and productivity, which leads to higher software delivery performance. However, this presents enterprises with a problem: it’s challenging to gain visibility over these tools, support them, and improve them when there’s no standard solution.

Develocity meets this challenge head-on by providing support for a range of CI and build tools, so there’s no need to undertake expensive migration efforts to a single tool to observe or improve your continuous delivery pipelines.

Instead of replacing anything, Develocity provides a unified operational layer within an organization, offering consistent insights, analytics, and reliability regardless of build system or CI platform. Develocity enhances your CI existing tools—such as Jenkins, GitHub Actions, or GitLab CI and CircleCI—rather than replacing them. This leads to significantly improved continuous integration practices and provides unique capabilities for governance, risk, and compliance.

Not only does Develocity provide visibility across these tools, Develocity deeply integrates with build/test tools, enabling optimizations (universal caching, parallelism, observability) that standard CI alone cannot provide. These optimizations improve your existing CI infrastructure to handle the rapid increase in pipeline volume driven by GenAI code, ensuring scalable and reliable pipeline performance without linear cost increases. In addition, using Develocity’s acceleration technologies locally enables fast feedback and reduces unnecessary reruns and pipeline congestion in CI, improving service quality and reducing costs.

Strategic outcomes:

• Speed up builds wherever and however they’re run: Develocity’s deep build tool integrations and support for CI systems enable optimizations regardless of the system running the build.
• Reduce CI operational costs and congestion: By accelerating builds and tests on developers’ local environments, Develocity reduces load on CI environments, improving CI service quality and reducing costs.
• Reduce pipeline disruptions: By proactively identifying bottlenecks and performance regressions, Develocity again helps improve service quality and reduce costs.

6. Scaling continuous delivery with Platform Engineering

Implementing continuous delivery practices at enterprise scale is hard. Every department and every team is doing things in a way that works best for them, but that may not translate to improved business outcomes when put into the context of the whole organization. There’s likely a mix of tools, no shared infrastructure, and a lack of centralized metrics. The logical first step is to improve tooling and processes at a CI level, focusing on automating build and test processes. But this approach cannot succeed alone.

Taking a proactive Platform Engineering approach acts as the force multiplier that turns good intentions, like faster and more reliable builds, into repeatable, scalable outcomes across teams.

Platform Engineering:

• Systematizes continuous delivery
• Enables self-service without sacrificing control
• Accelerates feedback loops
• Promotes standardization with flexibility

Develocity is a key enabler for Platform Engineering. It offers centralized observability for the build and CI tools in the organization. It accelerates CI and local feedback loops. It identifies productivity barriers so Platform Engineering teams can prioritize and address them. The benefits of adopting Platform Engineering practices (enabled by Develocity) include faster feedback loops, more reliable CI/CD pipelines, measurable productivity savings, and improved team morale. Platform Engineering elevates software delivery from reactive operational overhead to a strategic organizational competency.

DevOps introduced speed and automation. Developer Productivity Engineering (DPE) ensured sustained speed and productivity. Platform Engineering brought scale and systemization. Develocity is the platform that powers all three, delivering the visibility, intelligence, and control needed to continuously improve software delivery at every level.

Strategic Outcomes:

• Prioritize productivity barriers: Removing bottlenecks boosts build/test efficiency as well as reliability
• Proven benefits in major companies: Netflix and Applied Materials leverage Develocity to harvest real benefits in Platform Engineering
• Engineering rigor and observability: Develocity enables teams to scale delivery with speed, reliability, 
and control

Summary

Develocity strategically transforms continuous delivery from aspirational theory into an achievable practice. By addressing the core technical and organizational challenges—slow feedback cycles, inconsistent testing, poor observability—it provides a foundation for continuous improvement and innovation at scale by connecting engineering output to business outcomes.

Companies adopting Develocity find that releases become routine rather than exceptional events, freeing developer focus towards innovation and customer value creation. By shifting left to improve the developer feedback loop, improving observability and performance across all tools, and leveraging Platform Engineering to scale continuous delivery practices, organizations can achieve the measurable advantages identified by DORA—higher profitability, improved market responsiveness, and increased customer satisfaction.

Request a trial