Nov 17, live webinar: ECS to EKS without freezing the roadmap for a quarter

Blacksmith, Depot, Namespace or Qovery: CI acceleration vs a build-and-deploy platform (2026)

Blacksmith, Depot and Namespace make GitHub Actions and Docker builds faster. Qovery builds your image, pushes it and deploys it to Kubernetes in your own cloud. A fair 2026 comparison with prices checked on each vendor's page, and when to use an accelerator, a platform, or both.

Alessandro Carrano
Head of Product
NOV 17, 2026 · 19 MIN
Blacksmith, Depot, Namespace or Qovery: CI acceleration vs a build-and-deploy platform (2026)

Key points:

  • Blacksmith, Depot and Namespace are CI accelerators. They run your GitHub Actions jobs and Docker builds on faster machines with caches that stay warm between runs. None of them deploys the image to Kubernetes in your cloud or runs it afterwards.
  • Qovery is a build-and-deploy platform. It builds the image from Git, pushes it to a registry, deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account (or any cluster), and gives each pull request its own preview environment. It does not run your test suite and it is not a GitHub Actions runner.
  • Pick an accelerator when the pain is slow or expensive test jobs. Blacksmith is the simplest swap, Depot is the broadest toolbox (its own CI engine, registry, cache, sandboxes, and a managed option in your AWS account), and Namespace suits teams that want runners plus devboxes for agents.
  • Pick Qovery when the pain is everything after the build: registry wiring, deploy scripts, environments, previews, rollback and access control for people and agents.
  • Many teams should use both. Keep the accelerator for tests. Let Qovery build the deploy image and ship it. Prices below were read on each vendor's own pricing page on 17 November 2026.

Qovery · Infrastructure control plane
A control plane for platform teams and their coding agents
Learn more

"GitHub Actions is slow at building our Docker images" is one of the most common complaints I hear from teams we talk to. The usual answer online is a list of runner vendors. That list is fine, but it mixes two different problems. One is "my CI jobs take too long". The other is "I have a whole pipeline from commit to running container, and the build is only the first step".

Blacksmith, Depot and Namespace solve the first problem well. Qovery, where I work, solves the second. I wrote this guide so you can tell which problem you have, what each vendor ships today, and what it costs, with every price linked to the vendor's own page. I also say where Qovery is the wrong pick.

We have not benchmarked Qovery against Blacksmith, Depot or Namespace, so every speed number below for those three is their own claim, and I attribute it. Our own numbers are measured against GitHub's standard runner, and I link the public benchmark.

How did we pick and judge the options?

We judged five options (GitHub-hosted runners as the baseline, Blacksmith, Depot, Namespace and Qovery) on six criteria that decide which tool fits which problem.

  1. Where your CI jobs run. Is it a drop-in GitHub Actions runner, its own CI engine, or neither?
  2. Docker image builds. Does it build container images, and does the layer cache persist between builds?
  3. Registry. Does it store the image, or do you bring your own?
  4. Runs in your cloud. Can the compute run inside your own cloud account, so code, secrets and images stay there?
  5. Deploys and runs the app. Does it take the image to Kubernetes, run it, give each pull request an environment, and roll back?
  6. Published prices. Can you price it from a public page today, without a sales call?

Agent sandboxes got a column too, because coding agents now open a growing share of pull requests and several vendors build for them. GitHub's Octoverse 2025 counted more than 1 million pull requests created by the Copilot coding agent between May and September 2025, on top of 43.2 million pull requests merged per month across GitHub (+23% year over year). More pull requests means more CI runs and more builds, whichever tool you pick.

Which tool does what? The comparison table

Blacksmith, Depot and Namespace all accelerate CI and builds, and Depot covers the most ground of the three. Only Qovery deploys the image to Kubernetes in your cloud and runs it with environments and per-PR previews.

CapabilityGitHub-hosted runnersBlacksmithDepotNamespaceQovery
Best forThe default, no extra vendorCheapest drop-in swap for GitHub Actions runnersTeams that want a full CI and build toolbox, optionally in their own AWSRunners plus devboxes for agents, broad OS coverageBuild, push and deploy to Kubernetes in your own cloud, with previews
GitHub Actions runnersYes, standard and larger runners (pricing)Yes, Ubuntu x64 and ARM, Windows, macOS M4 (pricing)Yes (pricing)Yes, Linux, Windows, macOS (pricing)No, Qovery is not a runner
Docker image buildsYes, inside your workflow with BuildxYes, with Docker layer caching on NVMeYes, dedicated container buildersYes, Docker builds billed per buildYes, from your Dockerfile on every push
RegistryGitHub Container Registry, separate productNoYes, Depot RegistryYes, container registryPushes to a registry in your cloud account, then deploys from it
Own CI engineGitHub Actions itselfNo, runs your GitHub Actions jobsYes, Depot CI runs GitHub Actions YAML on Depot computeNo published CI engine, runners and Bazel remote executionNo, keep your CI for tests
Agent sandboxesNoTestbox, early beta (Sandboxes announced as coming soon)Yes, Depot Sandboxes and Managed AgentsYes, DevboxesNo sandboxes; agents deploy through the MCP Server, Agent Skills and scoped API Policy Tokens
Runs in your cloudSelf-hosted runners, you operate themNoYes, Depot Managed on AWS for customers working with DepotNo published optionYes, the app runs in your AWS, GCP, Azure or Scaleway account or your cluster
Deploys to KubernetesNo, you write the deploy stepNoNoNoYes
Runtime (runs the app afterwards)NoNoNoNoYes, on your Kubernetes cluster, with rollback
Preview environment per pull requestNo, you build itNoNoNoYes, created on PR open, deleted on merge or close
Published prices (17 Nov 2026)Linux 2-core x64 $0.006/minUbuntu x64 from $0.004/min, 3,000 free min/monthDeveloper $20/mo, Startup $200/mo, builds $0.04/min over planTeam $100/mo, Business $250/mo, Linux 2 vCPU $0.002 to $0.003/minFree plan, then Starter $299/mo, Growth $899/mo, Scale $2,999/mo

"Runs in your cloud" and "has a registry" are not unique to Qovery, since Depot has both and Namespace has a registry. The last three capability rows (deploy, runtime, previews) are empty for every accelerator, because none of them deploys.

Which problem do you have?

If your pull requests wait on slow test jobs, you have a CI speed problem, and an accelerator is the shortest path. If your pull requests wait on a deploy pipeline you maintain yourself, you have a delivery problem, and a faster runner will shave minutes off a pipeline you still have to own.

To tell which, open the last 20 runs of your main workflow and split the time into three buckets:

  • Tests and checks: lint, unit, integration. Accelerators shine here.
  • Image build and push: docker build, cache import and export, push to the registry. Accelerators and Qovery both do this.
  • Everything after the push: Helm or kubectl apply, waiting for rollout, preview environment scripts, cleanup jobs, secrets wiring. Only a deployment platform removes this bucket, because it removes the code you wrote to do it.

GitHub bills every job rounded up to the next whole minute (GitHub docs), and larger runners need the Team or Enterprise Cloud plan. When most of your time sits in the first bucket, keep reading the accelerator sections. When the third bucket is where your engineers lose their afternoons, the Qovery section is the relevant one.

If your workflows themselves are the problem (no cache, no concurrency groups, every job on every push), fix those first. Our 20 ways to speed up GitHub Actions covers that, and its tip 6 already summarises the faster-runner option in a paragraph.

Blacksmith: best for the cheapest one-line swap

Blacksmith is the right pick if you want your existing GitHub Actions workflows to run faster and cost less per minute with almost no change. It is the wrong pick if you need a registry, your own cloud account, or anything that deploys.

Blacksmith replaces GitHub-hosted runners with its own machines. The quickstart maps ubuntu-latest to a label such as blacksmith-2vcpu-ubuntu-2404, so the change is the runs-on: line.

What Blacksmith says about itself, on its homepage: "2x faster hardware" from "bare metal gaming CPUs with the highest single-core performance", "4x faster cache downloads" by co-locating cache artifacts in the same data center, and "40x faster Docker builds" by persisting Docker layers on NVMe drives across runs. These are vendor claims. One independent data point: Cal.com wrote that cache downloads were about twice as fast on Blacksmith (Cal.com).

Prices on the Blacksmith pricing page on 17 November 2026:

  • Ubuntu x64 $0.004/min at 2 vCPU (larger runners cost more per minute), Ubuntu ARM from $0.0025/min, Windows x64 from $0.008/min, macOS M4 $0.08/min.
  • 3,000 free minutes a month on all plans.
  • Docker layer caching and sticky disks at $0.50/GB-month each, static IPs at $100/IP/month.

Beyond runners, Blacksmith ships a console for GitHub Actions observability (job performance, log search, inline PR comments for failed tests). For coding agents it has Testbox, which syncs an agent's local changes to a Blacksmith runner and runs commands inside a real GitHub Actions job. Its docs call the CLI "agent-first" and say Testboxes are in early beta (Blacksmith docs).

Who should not pick Blacksmith: teams that need the build compute inside their own cloud account for compliance, or teams whose real bottleneck is the deploy pipeline. Blacksmith stops at the end of the CI job.

Depot: best for the broadest CI and build toolbox

Depot is the right pick if you want one vendor for fast runners, container builds, cache, a registry and agent sandboxes, with the option to run the build plane in your own AWS account. It is the wrong pick if you want the vendor to deploy and run your production app, which Depot does not do.

Depot has grown well past "fast Docker builds". Its homepage lists Depot CI, Depot Registry, Depot Code (Git-based source control "built for agents and engineers"), Depot Cache, container builds, GitHub Actions runners, and Managed Agents and Sandboxes. Depot CI is its own engine: the docs describe it as "an entirely new CI engine, not a wrapper around GitHub Actions", designed "to run your existing GitHub Actions YAML without modification" (Depot CI docs).

Depot's own claims: "40x faster container image builds", "10x faster builds with persistent, shared cache", and a "10x faster programmable CI engine". These are vendor numbers too. PostHog published a 12% to 13% shorter average job on Depot runners (Depot case study), which is a customer number on the vendor's site.

Prices on the Depot pricing page on 17 November 2026:

  • Developer, $20/month: 2,000 GitHub Actions minutes, 500 container build minutes, 2,000 sandbox minutes, 25 GB cache and registry storage, 1 user.
  • Startup, $200/month: 20,000 Actions minutes, 5,000 build minutes, 20,000 sandbox minutes, 250 GB storage, unlimited users.
  • Business: custom, with dedicated infrastructure, GPU builds, static IPs, PrivateLink and SSO.
  • Over the plan: container builds $0.04/min (default 16-vCPU builder), GitHub Actions runners $0.006/min (2-vCPU Linux), sandbox compute $0.00005 per second per vCPU, storage $0.20/GB-month.

The own-cloud option is real. With Depot Managed on AWS, "the Depot data plane is deployed within an isolated sub-account of your AWS organization", and the build compute and cache stay in your account (Depot docs). The docs say it is for customers working with the Depot team, so expect a conversation rather than a self-serve toggle.

Who should not pick Depot: teams on GCP, Azure or Scaleway who need the build plane in their own account (the managed option documented today is AWS), and teams that want deployments, environments and runtime from the same vendor. You still need something to take Depot's image to your cluster.

Namespace: best for runners plus devboxes at agent scale

Namespace is the right pick if you want fast runners across Linux, Windows and macOS, Bazel remote execution, and devboxes where agents run untrusted code. It is the wrong pick if you need the compute in your own cloud account or a deploy step.

Namespace pitches itself as a "developer platform for agent scale" (homepage). Products: compute instances (Linux up to 64 vCPU and 512 GB, Windows up to 32 vCPU, macOS up to 16 vCPU), GitHub Actions runners, Bazel remote execution, Docker builds, a container registry, cache volumes and Devboxes, which it describes as cloud development environments for agents ("Sandboxes aren't enough. Your cloud agents need a Devbox").

Prices on the Namespace pricing page on 17 November 2026:

  • Developer: pay as you go. Team: $100/month with 100,000 unit minutes and 1,000 Docker builds. Business: $250/month with 250,000 unit minutes and 2,500 Docker builds. Enterprise: custom.
  • Linux runners per minute, prepaid or overage: 2 vCPU $0.002 or $0.003, 4 vCPU $0.004 or $0.006, 8 vCPU $0.008 or $0.012. Windows costs 2x, macOS 10x.
  • Docker builds $0.05 per build on Developer, $10 per 1,000 builds over plan on Team and Business. Registry $0.20/GB-month.
  • Devbox Plus $250/month with 50,000 devbox minutes.

Per-build pricing for Docker is unusual, and it can work in your favour for long builds and against you for many tiny ones. Do the math on your own build mix.

Namespace runs on its own infrastructure, and I found no published option to run it in your own cloud account. It does not deploy or run your production app.

Who should not pick Namespace: teams whose security review requires source, secrets and images to stay in their own cloud account during the build, and teams looking for a deploy and runtime story.

Keep your fast runners. Let Qovery build and deploy.
Qovery builds your image, pushes it and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with a preview environment per pull request. Free plan, no credit card.

GitHub-hosted runners: the baseline you already pay for

GitHub-hosted runners are the right default when your jobs are short and your workflows are well cached. They are a weaker fit for heavy Docker builds without a warm cache.

Prices from GitHub's runner pricing reference: Linux 1-core $0.002/min, 2-core x64 $0.006/min, 2-core arm64 $0.005/min. x64 larger runners cost $0.012 (4-core), $0.022 (8-core), $0.042 (16-core), $0.082 (32-core) and $0.162 (64-core) a minute. Every job rounds up to a whole minute, larger runners need the Team or Enterprise Cloud plan, and they are not free for public repositories.

The baseline matters because every accelerator prices against it, and because it is the runner we measure Qovery against.

Qovery: best when the build is the start of a deploy

Qovery is the right pick when you want one path from a Git push to a running container on Kubernetes in your own cloud account, with environments, a preview per pull request and rollback. It is the wrong pick if all you want is cheaper or faster CI minutes, or a place to run your tests.

When you push, Qovery builds the image from your Dockerfile, pushes it to a registry in your cloud account and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or on any existing cluster (EKS, GKE, AKS, Kapsule, k3s, on-premise). You get environments, a preview environment per pull request that is deleted on merge or close, rollback, RBAC, audit logs, and API Policy Tokens to scope what an agent may do. By default, builds run on a pool of build workers on Qovery's side, in a separate Kubernetes cluster dedicated to builds. Building on your own cluster is an option. The app itself always runs in your account; Qovery is the control plane and never hosts it.

Build speed was our weak point, and I would rather say it than have you find it. In September, on our public benchmark (empty build, Node.js, Python FastAPI, React and Vite, Next.js standalone, PHP, and a roughly 2.5 GB image, timed from checkout to image in the registry), Qovery was 1.4x to 3.6x slower than GitHub's standard ubuntu-latest runner with Buildx. In October we moved builders from 8 GB to 16 GB of RAM, put builder nodes on local NVMe, switched images and cache to zstd, and stopped re-cloning when the image already exists. Across all customer builds, the median build went from about 3 minutes at the end of September to under 1.5 minutes in November, and the 95th percentile from about 11.5 to about 6 minutes.

Docker's buildx v0.39 (released 11 November, running on Qovery since 12 November) removed a wait of about 26 seconds per build. On the 13 November benchmark, Qovery matched GitHub Actions on typical apps and was faster on heavier builds: Python, Next.js and the large image finished in 0.86x to 0.90x of GitHub's time. The full story, including what is still slower, is in Making Qovery builds as fast as GitHub Actions, and then faster.

Since 12 November, a first group of customers sees per-step build timing in deployment logs and the Build Optimizer, which reads your Dockerfile, build logs and cache history and proposes a corrected Dockerfile. Persistent builder cache, faster CPUs and "build once, deploy many" are on our roadmap, not shipped.

On cost, Qovery is not cheaper per minute. Builds count toward your plan's deployment minutes, which also cover deploy time: 1,000 a month on Free (no overage billing), 3,000 on Starter at $299/month, 8,000 on Growth at $899/month and 30,000 on Scale at $2,999/month, with overage at $0.16 per minute (Qovery pricing). That is more per minute than any runner in this article. The cost case for Qovery is that you stop maintaining a separate CD pipeline, preview scripts and cleanup jobs, and you need fewer tools to get a commit running in your cloud.

Who should not pick Qovery: teams that only need faster test jobs, teams whose deploy story already works and only the CI bill hurts, and teams that do not run containers. For those, an accelerator from the sections above is the better buy.

Should we use both an accelerator and Qovery?

Yes, if your tests are slow and your deploy pipeline is a burden. Run tests on Blacksmith, Depot or Namespace runners, and let Qovery build the deploy image and ship it.

Here is the split I recommend to teams who ask:

StepWhere it runsWhy
Lint, unit and integration testsYour accelerator's runners (or GitHub-hosted)That is what they are built and priced for
Build the image you deployQoveryThe build runs next to the deploy, with per-step logs
Push to registryQovery, to a registry in your cloud accountNo registry credentials in CI
Deploy and runQovery, on Kubernetes in your AWS, GCP, Azure or Scaleway account or your clusterEnvironments, rollback, RBAC and audit logs come with it
Preview per pull requestQoveryCreated on PR open, deleted on merge or close
End-to-end tests against the preview URLYour accelerator's runnersTests stay in CI, against a real environment

In practice the workflow file gets shorter. Your test job keeps a runs-on: label from your accelerator, for example blacksmith-2vcpu-ubuntu-2404. The docker build, docker push and kubectl apply steps disappear, because Qovery reacts to the push and to the pull request through its own Git integration. You no longer write a deploy workflow or a cleanup workflow.

If your accelerator already builds a Docker image for your tests, you now build twice (once for tests, once to deploy). That is fine when the test image is small. When it is not, run the tests inside the preview environment Qovery deployed, or point integration tests at the preview URL, so one build serves both.

Depot's registry and Depot Managed on AWS overlap with parts of what Qovery does, and the two can sit side by side. Nothing in this setup asks you to drop a vendor you are happy with.

Is Depot or Blacksmith enough, or do we still need a deployment platform?

Depot or Blacksmith is enough if you already have a deploy path you trust, such as Argo CD watching a Git repo, a managed PaaS, or a Helm step your team is happy to maintain. You still need a deployment platform, or something you build, when nobody owns the path from image to running environment.

Signs you need more than an accelerator:

  • Your CI workflow has more deploy steps than test steps.
  • Preview environments live in a pile of Terraform and shell scripts one person understands.
  • Rollback means re-running an old workflow and hoping.
  • Coding agents open pull requests nobody can try without pulling the branch locally.
  • Your security team asks who can deploy what, and the honest answer is "anyone with the CI secrets".

None of the three accelerators tries to solve those. Their products end at the CI job, the image or the sandbox. If those signs fit, look at Qovery or at the other options in our GitHub Actions alternatives and preview environments for AI coding agents guides.

Which platforms build from Git, push to a registry and deploy to Kubernetes in one step?

Qovery does all three from a Git push, into your own cloud account. Other ways to get there exist, with more assembly: GitHub Actions plus Argo CD, GitLab CI with its registry and a Kubernetes deploy job, or Argo CD Image Updater after any CI that pushes an image.

OptionBuild from GitRegistryDeploy to KubernetesPreview per PRWhat you maintain
QoveryYesYes, in your cloud accountYes, your cluster in your accountYesDockerfile and Qovery config (Console, Terraform provider or API)
GitHub Actions + Argo CDYes (Actions)GHCR or your ownYes (Argo CD)With ApplicationSets and extra setupWorkflows, manifests, Argo CD itself
Accelerator + Argo CDYes (fast runners)Depot or Namespace registry, or your ownYes (Argo CD)With ApplicationSets and extra setupWorkflows, manifests, Argo CD itself
GitLab CI + Kubernetes jobYesGitLab registryYes, via your deploy jobWith review apps and extra setupPipelines, manifests, cluster access

The Argo CD rows are good setups. They mean your team owns more moving parts, which is the right trade for a team with platform engineers and the wrong one for a team without.

How do I try this from Claude Code or Cursor?

Install the Qovery Agent Skills and your coding agent can deploy a repository to Kubernetes in your own cloud account through the Qovery API, while your existing CI keeps running the tests. These are the commands, in order.

BASH|1. Agent Skills, global: Claude Code, Cursor, Codex, OpenCode, Gemini CLI and others
curl -fsSL https://skill.qovery.com/install.sh | bash

# 2. Or scoped to the current project
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

# 3. MCP Server for Claude Code, OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242

# 4. Write access, only when you explicitly want it (also needs write access enabled in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242

Your agent asks you to approve each install command, and the MCP Server opens an OAuth login in your browser. Then ask in plain language: "deploy this app to my AWS account with Qovery". The skills deploy (qovery-onboard, qovery-deploy, qovery-preview, qovery-speedup among them); the MCP Server operates what already exists. Start with the AI agent quickstart or the Claude Code integration.

Frequently asked questions
Blacksmith vs Depot vs Namespace: which GitHub Actions runner accelerator should we pick?

Pick Blacksmith for the simplest swap and the lowest published Ubuntu x64 entry price ($0.004/min at 2 vCPU, 3,000 free minutes a month). Pick Depot if you want its own CI engine, registry, cache, sandboxes and an option to run in your AWS account. Pick Namespace for runners across Linux, Windows and macOS plus devboxes for agents. Test the two closest fits on your own slowest workflow, because their speed figures are vendor claims.

Is Depot or Blacksmith enough, or do we still need a deployment platform?

They are enough if you already have a deploy path you trust, such as Argo CD or a well-kept Helm step. Neither deploys the image to Kubernetes in your cloud or runs it, so without a deploy path you still need a platform like Qovery or something you build and maintain yourself. Many teams keep the accelerator for tests and use Qovery for build and deploy.

GitHub Actions is slow at building our Docker images. What are our options?

First fix the workflow: layer cache with Buildx, a Dockerfile that installs dependencies before copying source, and concurrency groups. Then you can move builds to an accelerator with persistent layer caches (Blacksmith, Depot, Namespace), or move the deploy build to a platform that builds and deploys in one step, like Qovery. Measure your own builds before and after, since every vendor publishes its own speed figures.

Which platforms build from Git, push to a registry and deploy to Kubernetes in one step?

Qovery builds from a Git push, pushes to a registry in your cloud account and deploys to Kubernetes in your own AWS, GCP, Azure or Scaleway account or your existing cluster, with a preview environment per pull request. GitHub Actions or GitLab CI combined with Argo CD reach the same result with more pieces for your team to maintain.

Is Qovery faster than Blacksmith, Depot or Namespace?

We don't know, because we have not benchmarked against them, and I won't claim it. Our public benchmark compares Qovery with GitHub's standard runner: on 13 November 2026 Qovery matched it on typical apps and finished Python, Next.js and large-image builds in 0.86x to 0.90x of GitHub's time.

Is Qovery cheaper per build minute than these runners?

No. Qovery's overage is $0.16 per deployment minute, which covers build and deploy time, and that is more per minute than GitHub-hosted runners or any accelerator here. The saving, when there is one, comes from dropping a separate CD pipeline, preview scripts and the time your team spends maintaining them.

Alessandro Carrano
About the author
Alessandro Carrano

Alessandro leads product at Qovery. He drives the changelog, roadmap, and product strategy - turning customer feedback into platform capabilities.

Next step

Keep your fast runners. Let Qovery build and deploy.

Qovery builds your image, pushes it and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with a preview environment per pull request. Free plan, no credit card.