Remote Docker Builders: Sizes and Pricing

For GitHub Actions, WarpBuild remote Docker builders keep a persistent layer cache on each builder profile. Profiles come in seven sizes, from 16 vCPU with 32GB memory and 100GB disk at $0.06 per minute to 192 vCPU with 384GB memory and 2TB disk at $0.88 per minute. Each profile is billed per session, from the first job start to the last job completion on that profile.

Billing is per session, not per job, so several jobs on one profile at the same time share one billed session at the rates on the pricing page.

Which Docker builder sizes can you choose?Copy Anchor Link

There are seven builder profile sizes, from 16 vCPU to 192 vCPU, with rates on the pricing page. You create a builder profile once on the Docker builders page in the dashboard, then select it from a workflow by name.

Which sizes support arm64 and multi-arch builds?Copy Anchor Link

arm64 and multi-arch profiles support sizes up to 64 vCPU. The 96 vCPU and 192 vCPU sizes are amd64 only, in both the 600GB and the 2TB disk variants.

If the amd64 image needs a larger machine, you can use two profiles instead of one multi-arch profile. Use an amd64-only profile that can grow past 64 vCPU and a separate arm64 profile at 64 vCPU or below. Each profile keeps its own layer cache.

Samaya AI runs tens of Docker builds per pull request across ARM64 and x64 on WarpBuild remote Docker builders, and its platform serves 10,000+ seats. Read the Samaya AI case study.

How long does the layer cache last?Copy Anchor Link

The layer cache stays on the builder profile between builds. It is reset automatically if the profile is not used for more than 10 days.

A profile that only runs rarely, for example one used by a monthly release workflow, will often start without a cache. Point those workflows at a profile that a busier workflow also uses, so the cache stays in use between releases.

How do Docker builders scale when many builds run at once?Copy Anchor Link

WarpBuild Docker builders support scaling out under high concurrency. A builder profile runs on one builder VM, and extra builders can start when many builds run on the profile at the same time. You keep the same action and the same profile name in your workflow.

Extra builders share the profile's cache, so they start with the layers that earlier builds cached.

The cache between builds that run at the same time is shared but eventually consistent. A layer that one build has just cached may not be available yet to another build running at the same time, but it is available to later builds.

How many builds fit on one builder?Copy Anchor Link

Plan for about 8 vCPU and 16GB memory per concurrent build job on one builder. This is the recommended minimum per build. At that size per build, one 64 vCPU builder fits about eight builds at once, and one 192 vCPU builder fits about twenty-four. There is no limit on the number of builds that can run at the same time on a builder profile.

How much does each Docker builder size cost?Copy Anchor Link

Builder time costs from $0.06 per minute for 16 vCPU to $0.88 per minute for 192 vCPU with 2TB disk, at the rates on the pricing page. The per-hour and 5-minute costs in the table are calculated from the per-minute rate.

What counts as a billed session?Copy Anchor Link

A session starts when the builder action starts and ends when the job completes. Multiple concurrent jobs on the same builder profile share one session, billed from the first job start to the last job completion.

Example: two jobs use the same amd64 profile and their run times overlap. Job A takes the builder at minute 0 and finishes at minute 8. Job B takes the same builder at minute 3 and finishes at minute 12. That is billed as one session of 12 minutes, not 8 minutes plus 9 minutes. On a 32 vCPU profile at $0.12 per minute the session costs $1.44.

Steps that run after the build keep the session open until the job completes. A push to a slow registry, a scan, or a long post-action step all add to the session. Move work that does not need the builder out of that job when you can.

Are the runner and the builder billed separately?Copy Anchor Link

Yes. The runner and the builder are both charged. The runner is billed per minute at its own rate, and the builder is billed per session at the profile rate.

Example: a pull request builds four service images in parallel on one 32 vCPU profile. Each job runs on warp-ubuntu-latest-x64-4x, which is listed at $0.008 per minute in the cloud runners documentation.

How are multi-arch builds billed?Copy Anchor Link

A multi-arch build runs each architecture on its own builder instance, so it creates one session per architecture on the same profile. The two sessions are billed independently, and each stays open until its post-action steps complete.

Example: on a 64 vCPU multi-arch profile at $0.24 per minute, with a 6-minute build per architecture, the cost is 2 sessions x 6 minutes x $0.24, which is $2.88 of builder time per pull request, plus runner minutes. Plan for multi-arch to cost about twice the builder time of one architecture, then compare it with two single-architecture profiles, where the amd64 side can use a larger machine.

Where do builder costs show up?Copy Anchor Link

Docker builder costs have their own Docker builders tab on the Spend page, which the reports documentation covers. Each row is one Docker builder session, with its profile, architecture, duration and cost, so you can find a profile that runs long sessions for short builds.

How do you use a builder profile in a GitHub Actions workflow?Copy Anchor Link

Replace docker/build-push-action with Warpbuilds/build-push-action@v7 and pass the builder profile name in profile-name. The other inputs stay the same.

name: build-image
on: push

jobs:
  image:
    runs-on: warp-ubuntu-latest-x64-4x
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v7

      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push
        uses: Warpbuilds/build-push-action@v7
        with:
          context: .
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}
          profile-name: "app-images-32x"
          timeout: 600000

Remove any docker/setup-buildx-action step that exists only to create a builder, and remove cache-from and cache-to. The builder profile caches layers and reuses them in the next build without cache flags.

For multi-arch, use the same action with a platforms input, against a profile that has both architectures enabled:

      - name: Build and push multi-arch
        uses: Warpbuilds/build-push-action@v7
        with:
          context: .
          push: true
          platforms: linux/amd64,linux/arm64
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}
          profile-name: "app-images-multi-64x"

Does the runner size change the builder size?Copy Anchor Link

No. The size of the builder profile has no relationship to the size of the GitHub Actions runner that drives it. In the example above, a 4 vCPU runner checks out the repository and calls the action, and the build itself runs on the 32 vCPU builder.

Size each resource for its own work. Size the runner for checkout, tests and the other steps in the job, and size the builder for the images using the 8 vCPU and 16GB memory per build guideline above.

Builder profiles also work from runners that are not WarpBuild runners, such as GitHub-hosted runners. On those runners, pass a WarpBuild API key in the api-key input. WarpBuild runners do not need it.

For the full setup steps, including the bake action and the CLI, read Remote Docker Builders for GitHub Actions. Build patterns and matrix layouts are in Docker Builds on GitHub Actions: Remote Builders. If you are still choosing between a registry cache and a remote builder, read Choosing a Buildx Cache Backend on GitHub Actions. For the concept on its own, see What Is a Remote Docker Builder?. Runner labels and their rates are in the cloud runners documentation.