Reduce Build & Test Times
Up to 90% Instantly with

Build Cache & Test Distribution

Develocity build and test acceleration technologies address the pain of unnecessary developer idle time waiting for builds and tests to complete. This results in happier, more productive developers, and faster feedback cycles.

Benefits of Faster Feedback Cycles

Increased Developer Productivity 

Fast feedback cycles are important to productivity since developers spend less idle time waiting for builds to complete. There is also less impact to the creative process. This means that since builds complete quickly, developers are less tempted to pay the context-switching cost of starting and stopping other tasks and activities.

Less Difficulty Troubleshooting

Faster feedback cycles will change developer behavior in other positive ways, including encouraging developers to run builds and tests more often rather than pushing quality checks to later stages of the development cycle. Building more often means developers spend less time debugging problems that occur from compounding changesets. Another benefit of smaller changesets is the lower likelihood of merge conflicts and stale feature branches and pull requests.

Higher Quality Software

Building and testing more often is also safer because there is less chance of defects passing through quality gates, and companies aren’t tempted to cut corners like turning off tests and other safety measures in order to ship faster.


Key Solution Components include Build Cache, Test Distribution and Performance Profiling

Build Cache

Build Cache allows you to share and reuse unchanged build and test outputs across the team. This speeds up local and CI builds since cycles are not wasted re-building components that are unaffected by new code changes. Develocity Build Cache supports both Gradle and Maven build tool environments. To learn more about how Build Cache differs from binary repositories, click here.


Easy to Use

Deploy, manage and operate with very little effort.

Multi-zone Replication

Create replicating caches near your developers for faster access and faster builds.

Optimized Builds

Use in conjunction with Build Scan™ to make your build faster by making better use of the cache.

Test Distribution

Often when developers say their builds are slow, they really mean their tests are slow or they believe their builds are fine, but their tests are slow. Either way test time is often the key driver of build times. There are many factors that contribute to test time including the growing number of integration and functional tests to cover a wide range of inputs, running tests sequentially, and dependencies on expensive external services.

Test Distribution is an approach that accelerates test execution and complements build caching while addressing many of the limitations of single-machine parallelism and CI fanout. And it gets around limitations in the number of parallel forks dictated by a single machine’s CPU and memory resources. It does this by extending test parallelism by fanning out test execution to remote executors.

The Develocity extension for the Maven & Gradle build tool coordinates partitioning of the test set and collection of results, while Develocity requests and caches test inputs, executes tests, and reports results back to the build tool for storage, all that with a low overhead that allows for fine-grained distribution.

Limitations of Existing Test Acceleration Techniques

  • Build Caching is great in many cases but doesn’t help when test inputs have changed.
  • Single machine parallelism is limited by that machine’s resources.
  • CI fanout does not help during local development, is inefficient (in particular on ephemeral CI agents or without build cache), requires manual setup and test partitioning, and causes disjoint test reporting.


Uses single-machine parallelism when no agents are available or in combination with remote agents (ensures test distribution will never be slower)

Requires a simple change to the build configuration to enable

Partitions test sets automatically

Works for local and CI builds

Shows the results of all tests via test reports and Build Scan™

Makes Information about used agents available in the Build Scan™

Transfers and merges outputs back to the build automatically (e.g. JaCoCo)

Allows running a subset of tests on specific agents based on requirements specified in the build configuration (e.g. certain tests should only run on agents with a specific OS)

Runs on-premise inside your own network infrastructure


Here is actual test time savings experienced by Develocity Test Distribution customers and how that translates directly into hard annual savings in terms of developer years and cost.

Performance Profiling

Performance Profiling is the analytics capability associated with the Develocity Build Cache and Test Distribution solutions. It sets up easily and scales to the largest builds on the planet.

 It leverages Build Scan™ and the Build & Test Performance Trends dashboard to give build engineers the insights to continually audit and tune build and cache performance. 

For example, the Build & Test Performance Trends dashboard allows you to filter for and discover builds with specific performance characteristics or anomalies like builds with slow dependency download times, bad parallelism or low cache effectiveness. The associated Build Scan™ then allows you to determine the root cause of these anomalies. For example, the Build Scan™ can help you determine whether a high dependency download time is caused by a network bandwidth constraint or a high level of data traffic.

Develocity screenshots of performance dashboards used to identify slow Java and Android builds and unlock ways to speed them up.

Use the Trends Dasbhoard to observe when your Maven or Gradle build times are regressing and the Performance Dashboard to understand why.

Get started today

Request a 30-day free trial of Develocity.
Free 30-day trial