New article: A Model of the AI-Native SDLC — read the article

All Blog Posts
October 30, 2026

How our CI replaced 55 GB of baked-in Docker images with Artifact Cache

By Iveta Dulova

At Develocity, dogfooding is a core part of how we build software: every capability we ship runs in our own CI first, on the same pipelines our engineers depend on every day. Docker image caching in Develocity Artifact Cache was no exception.

Before we shipped it, we turned it on in our own CI. Our agents no longer carry 55 GB of baked-in Docker data, 97% of the images jobs used came from the cache, and one pipeline run restores 21 GB of image layers from the Edge instead of the registry.

This post covers what changed for each kind of Docker use in our pipeline, what it costs us, and where it doesn't help yet. The numbers come from our own ready-for-merge pipeline, in which 96 of 244 jobs restore Docker images.

Our CI agents used to get their images the usual way: baked in. The agent machine image shipped about 55 GB of Docker data to every agent, whether a job needed it or not.

Now every job starts with an empty Docker image store, like any ephemeral runner, and restores only the images it uses. Each image comes either from the registry or from the cache, which made the effect easy to measure.

Our CI already uses Artifact Cache, so enabling Docker caching was largely a matter of upgrading the Artifact Cache CLI version and reviewing our CI agent image content. Docker caching arrived in Artifact Cache CLI 1.9 and is on by default whenever docker is on the agent's PATH and the Docker daemon is online.

Two kinds of CI job needed additional configuration. CI jobs that create a fresh buildx builder need --enable-docker-builders, because those builders keep their own image store. Also, our own per-commit product images, which no later pipeline run reuses, are excluded by design. Everything else, from Testcontainers to k3d, picked up cached images without a change to a build script or Dockerfile.

The CLI records a Java Flight Recorder (JFR) event for every image it loads, with the image's size and how long docker load took. We combined those events with Develocity's own task data, Gradle and Docker Build Scan data, and TeamCity build logs.

Most pipeline-wide figures come from one full ready-for-merge pipeline run on 14 October. Where we compare before and after, we set the week before the change (1 to 4 October) against the week after it (7 to 14 October).

Each kind of Docker use in the pipeline gets its images from the cache. The biggest wins are in the slow tail of image builds and in the test database most jobs need.

Develocity CI, October 2026 · test database: task data and JFR load events; services: Gradle pull tasks; FROM: Docker Build Scan data; k3d: TeamCity build logs

The test database, postgres:18.4, is most of the traffic. 76 of the 96 restoring jobs need only that image, and it accounts for 658 of the 1,482 image loads we counted across seven pipeline runs. Restoring it instead of pulling it takes a job from 9.2 s to 5.0 s, which adds up to about 5 agent-minutes per pipeline run.

The base images in our Dockerfiles, including Liberica, distroless, Alpine, nginx and the docker/dockerfile frontend, are now restored instead of pulled. The biggest change is in the slow tail: the p90 of the Liberica FROM step fell from 20 s to 1.3 s.

Our heaviest image build, the one that publishes our Helm chart, restores 21 base images, 1 GB of layers, in 53 s instead of pulling them. Builds that create a fresh buildx builder in each job get the same treatment once --enable-docker-builders copies the base layers into the builder.

Our Helm system tests create a k3d cluster in each job. Its node images (rancher/k3s, k3d-tools, k3d-proxy and registry:2) were not pulled in any of 38 measured runs. Cluster creation went from 184 s to 138 s in the HTTPS connectivity tests, and from 94.5 s to 87.5 s in the standalone ones.

One pipeline run restores 21 GB of image layers from the Edge that jobs would otherwise pull from our registry, Artifactory.

Develocity CI · JFR restore metrics from the 96 jobs that loaded images, one ready-for-merge run, 14 Oct 2026

That traffic is where the savings come from. Artifactory stays the system of record for every image we use; the cache only takes over the repeat reads our ephemeral agents used to send it on every job. As AI raises the number of pipeline runs, that repeat traffic grows with them, and the Edge absorbs it instead of the registry.

Restoring isn't free. Loading images into Docker runs at about 100 MB/s on our agents, so load time follows image size: a 2.3 GB Hive image takes 19 s, the test database 3.3 s.

Across one pipeline run, that adds up to 196 image loads and about 12 agent-minutes of docker load. Storing is almost free, with a median of 0.8 s, because 94 of the 96 jobs reuse the images they restored.

Develocity CI · JFR image load events from all 96 jobs that loaded images, one ready-for-merge run, 14 Oct 2026

Load times also vary with whatever else the agent is doing. The same 505 MB postgres:18.4 image took anywhere from 1.7 s to 15.6 s to load across our runs.

  • Our own per-commit images. Images we build for each commit are excluded by design, so jobs still pull them: about 110 s per pipeline run.
  • Inside k3d clusters. Kubelet pulls our product images from the cluster's local registry, which the cache doesn't see. Loading those 25 images took 30 to 83 s across 12 runs.
  • Unused images and a mutable tag. About 6% of loads go unused in a given run. The cache keeps those images on purpose, so a job that skips its Docker work in one run still finds them in the next. Two images are cached under a mutable tag that should be pinned.

Pinning the two mutable tags is a fix on our side, not a limit of the cache. The per-commit images and the pulls inside k3d sit outside what the cache sees today, and they are the clearest remaining cost in our pipeline.

  • Count the bytes before the seconds. Traffic kept off the registry is the saving you get everywhere. Time saved depends on how far away your registry is.
  • Pin your tags. Images tagged latest, or untagged, always come from the registry.
  • Check where your containers run. The cache sees the agent's own Docker daemon. GitHub Actions services:, Kubernetes pod agents, a remote DOCKER_HOST and Testcontainers Cloud pull past it.
  • Size the Edge for your layers. At the 100 MiB default maximum artifact size, an image with a larger layer is never restored.

To see what your own pipelines spend on image pulls, start a free trial or read the Artifact Cache documentation.

Is GenAI stressing your Continuous Delivery pipeline?

GenAI Will Stress Your Continuous Delivery Pipeline whitepaper

Share this blog post

© 2026 Gradle, Inc. Gradle®, Develocity®, Build Scan®, and the Gradlephant logo are registered trademarks of Gradle, Inc.

Get an AI summary of Develocity: