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

Build and deploy to your own AWS account without paying for GitHub Actions minutes: ARC on EKS, managed runners, or Qovery

Three ways to stop paying GitHub per minute for Docker builds and deploys to your own AWS account: self-hosted runners on EKS with Actions Runner Controller, managed runners from Blacksmith, Depot or Namespace, or moving the image build and deploy to Qovery while tests stay in GitHub Actions. Real November 2026 prices, plus the costs that rarely reach the spreadsheet.

Guillaume Da Silva
Staff Solutions Architect
NOV 17, 2026 · 17 MIN
Build and deploy to your own AWS account without paying for GitHub Actions minutes: ARC on EKS, managed runners, or Qovery

Key points:

  • GitHub bills hosted runners per minute, rounded up per job: $0.006 for a 2-core Linux runner, $0.012 for 4-core, $0.022 for 8-core in November 2026. Self-hosted runners cost nothing on GitHub's side today, after GitHub postponed the $0.002/minute self-hosted fee it announced in December 2025.
  • Option 1, self-hosted runners on EKS with Actions Runner Controller (ARC): the cheapest per minute at high utilization (a 4 vCPU c7i.xlarge is about $0.003 a minute on demand in us-east-1), but you pay for the EKS control plane, idle nodes, cache storage, and the engineer who keeps it patched and secure.
  • Option 2, managed runners: Blacksmith ($0.004/min for 2 vCPU), Depot ($0.006/min runners, $0.04/min container builds, plans from $20/month) and Namespace ($0.003/min for 2 vCPU overage, plans from $100/month) swap one runs-on: line. You still write and run your own deploy pipeline.
  • Option 3, move image build and deploy to Qovery, keep tests in GitHub Actions: the build, the registry push, the Kubernetes deploy and preview environments run from one product into your own AWS account. It is not cheaper per minute ($0.16 overage per deployment minute on paid plans), so it pays off when it removes a deploy pipeline you would otherwise maintain.
  • My rule of thumb: high build volume and a platform team means ARC. Slow CI and a deploy setup you like means managed runners. No one who wants to own the deploy path means Qovery for build and deploy, with tests where they are.

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

I spend a lot of my week on calls with teams who want to cut their GitHub Actions bill. The conversation usually starts with "should we self-host runners on EKS?" and ends somewhere else, because the YAML, IAM and Helm around the build usually cost more than the minutes.

Romaric already covered the tuning side in 20 ways to speed up GitHub Actions and cut its cost, and that article ends with a short section on when to move the build out. Here I compare the three real exits, with each vendor's own November 2026 prices, a per-minute cost model you can redo with your numbers, and the costs that never make it into the spreadsheet.

How much do GitHub Actions minutes cost for Docker builds in 2026?

GitHub charges $0.006 a minute for a standard 2-core Linux runner in a private repository, and larger x64 runners roughly double in price with each doubling of cores. Every job is rounded up to the next whole minute, and larger runners are only available on the Team and Enterprise Cloud plans (GitHub).

Runner (Linux)Price per minutePrice per hour
1-core x64$0.002$0.12
2-core x64 (standard)$0.006$0.36
2-core arm64$0.005$0.30
4-core x64$0.012$0.72
8-core x64$0.022$1.32
16-core x64$0.042$2.52
4-core arm64$0.008$0.48

Source: GitHub Actions runner pricing, checked 17 November 2026.

A few rules shape the bill more than the price list:

  • Included usage is small. Free includes $12 of compute a month, Pro and Team $18, Enterprise Cloud $300 (GitHub billing docs). On a 2-core runner, $18 is 3,000 minutes.
  • Public repositories are free on standard runners. Larger runners are billed even on public repositories.
  • Self-hosted runners are free on GitHub's side. They don't consume included usage either.
  • That last point almost changed. On 16 December 2025, GitHub announced a $0.002 per minute "cloud platform charge" on self-hosted runner usage from 1 March 2026, then posted that it was "postponing the announced billing change for self-hosted GitHub Actions to take time to re-evaluate our approach" (GitHub changelog). Keep it in your model as a risk.

Here is a rough model for a team building Docker images. These are my assumptions, not measurements, so swap in yours:

ScenarioImage builds per monthAvg minutes billed per buildRunnerGitHub cost per month
10 engineers, humans only1,20064-core ($0.012)$86
Same team plus coding agents opening PRs6,00064-core ($0.012)$432
Same, on 8-core to cut wall time6,00048-core ($0.022)$528

The first row is why many teams should stop reading here and apply the tuning tips. The second row is what pushes teams into my calendar: agents multiply builds, and every build of every agent PR is billed.

Option 1: what does it take to run self-hosted runners on EKS with ARC?

Actions Runner Controller is GitHub's Kubernetes operator for self-hosted runners. You install two Helm charts on a cluster, it registers ephemeral runner pods with GitHub, scales them with the job queue, and you stop paying GitHub per minute. You pay AWS for the nodes and your team for everything else.

GitHub describes ARC as "a Kubernetes operator that orchestrates and scales self-hosted runners for GitHub Actions" (GitHub docs). The setup is the gha-runner-scale-set-controller chart plus one gha-runner-scale-set per runner group, published as OCI Helm packages. Runners are ephemeral pods that register with a just-in-time token, and you set minRunners and maxRunners per scale set.

What it costs on AWS

Line itemPrice (us-east-1, Nov 2026)Monthly, rough
EKS control plane$0.10 per cluster-hour (AWS)$73
c7i.xlarge node (4 vCPU, 8 GiB), on demand$0.179 per hour (Vantage, AWS on-demand price)per node-hour used
c7i.xlarge, spotabout $0.060 per hour (same source, varies)per node-hour used
Registry storage (ECR)$0.10 per GB-month (AWS)depends on retention
Cache volumes (EBS) and NAT trafficper GBdepends on setup

One 4 vCPU node at $0.179 an hour is about $0.003 a minute, against $0.012 for GitHub's 4-core runner. That is the number in every "self-host and save 75%" blog post. It assumes your nodes are busy 100% of the time.

They won't be. Builds arrive in bursts around working hours, and you either keep warm nodes (paying for idle) or scale from zero (paying in wait time while Karpenter or Cluster Autoscaler brings up a node). At 30% average utilization, the same node costs about $0.010 per useful minute, close to GitHub's $0.012. Spot capacity brings it back down, with the occasional interrupted job.

The costs that are not on the AWS bill

  • Docker builds need a decision on privileges. ARC's Docker-in-Docker mode "requires privileged mode". Kubernetes mode needs persistent volumes or container hooks, and GitHub's docs warn that running jobs without a container in that mode "can give the runner pod elevated privileges with the Kubernetes API server, including the ability to create pods and access secrets" (GitHub docs). Most teams end up with a dedicated cluster or node pool for runners, plus BuildKit or Kaniko.
  • Caches go cold. Ephemeral pods start empty. To get the speed you expected, you add a registry cache or persistent volumes for BuildKit, and then you manage their size and cleanup.
  • You own the patching. GitHub is explicit that with self-hosted runners "you are responsible for updating the operating system and all other software" and "for the cost of maintaining your runner machines" (GitHub docs). Runner images, the controller, node AMIs and the EKS version all move.
  • The deploy pipeline is still yours. ARC replaces the machine under runs-on:. Your ECR login, OIDC roles, kubeconfig step, Helm chart, environments and preview scripts stay exactly where they were.

ARC makes sense when you run a lot of builds, you already operate EKS with a platform engineer who knows it, and you want the builds inside your VPC for network or compliance reasons. Below that volume, the engineering time costs more than the minutes it saves.

Option 2: what do managed runners like Blacksmith, Depot and Namespace cost?

Managed runner services run your existing GitHub Actions jobs on their own faster machines, usually by changing the runs-on: label, and bill per minute at or below GitHub's prices. Most of the speed comes from caches that stay on local disks between runs. They do not deploy your app.

BlacksmithDepotNamespace
Linux x64 runner, per minute$0.004 (2 vCPU), $0.008 (4 vCPU), $0.016 (8 vCPU)$0.006 (2 vCPU) beyond plan minutes$0.003 (2 vCPU), $0.006 (4 vCPU) overage; $0.002 and $0.004 prepaid
Plan feeNone; 3,000 free minutes a monthDeveloper $20/month, Startup $200/monthTeam $100/month, Business $250/month
Included3,000 minutesDeveloper: 2,000 runner minutes, 500 container build minutes, 25 GB cacheTeam: 100,000 unit minutes, 2,500 Docker builds
Docker buildsOn the runner, Docker layer cache $0.50/GB-monthContainer builds $0.04/minute (16 vCPU builder)$10 per 1,000 builds over plan
Registry or cache storageSticky disks $0.50/GB-month$0.20/GB-month (cache and registry)$0.20/GB-month (registry and caches)
Runs in your AWS account?NoYes, with Depot Managed on AWS (enabled by Depot's team)No
Deploys to your cluster?NoNoNo
Sourceblacksmith.sh/pricingdepot.dev/pricingnamespace.so/pricing

Prices from each vendor's pricing page, checked 17 November 2026.

Their speed claims come from them. Blacksmith's pricing page advertises "2x faster" runs, and Depot's site says its container builds are "up to 40x faster". In Romaric's tuning guide, Cal.com reported cache downloads twice as fast on Blacksmith, and PostHog a 12% to 13% shorter average job on Depot (tip 6). I have no benchmark of my own against these three, and I would discount any vendor comparison you can't rerun.

Depot deserves a note on data residency. With Depot Managed on AWS, "the underlying build compute and cache infrastructure reside entirely within your own AWS account", in an isolated sub-account, and it is enabled by working with the Depot team (Depot docs). If your security team blocks builds on third-party machines, that changes the conversation.

With managed runners you still pay per minute, only to someone else, and the build still ends with an image in a registry. The deploy job, the cluster credentials, the environments and the preview environments are still your YAML.

Move the build and the deploy into your own AWS account.
Qovery builds your image, stores it in a registry in your cloud account and deploys it to Kubernetes on AWS, GCP, Azure, Scaleway or your own cluster, with a preview environment per pull request. Keep your tests in GitHub Actions.

Option 3: what changes if Qovery builds and deploys while tests stay in GitHub Actions?

You keep GitHub Actions for tests, linters and security scans, and you delete the build-push and deploy jobs. Qovery builds the image from the same commit, pushes it to a registry in your own cloud account, and deploys it to Kubernetes in that account, including a preview environment per pull request.

What moves, concretely:

  • Image build. By default, Qovery builds on a pool of build workers on Qovery's side, in a Kubernetes cluster dedicated to builds. You can choose to build on your own cluster instead.
  • Registry. The image lands in a mirroring registry in your cloud account. If an image with the same inputs (commit, Dockerfile, declared build arguments) already exists, Qovery skips the build entirely (Qovery docs).
  • Deploy. Rolling updates on Kubernetes, with automatic rollback when the new version fails to start (Qovery docs), on an EKS cluster Qovery manages in your AWS account or on a cluster you already run.
  • Environments and previews. Staging and production are cloned environments with RBAC per environment, and each pull request can get a full-stack preview that is deleted when the PR closes.

Everything that checks code stays in GitHub Actions. Your test minutes keep being billed by GitHub (or by your managed runner), so this option removes only the build and deploy minutes.

Is it fast enough?

In September 2026 it wasn't. Qovery builds were 1.4x to 3.6x slower than GitHub's ubuntu-latest runner on a public benchmark. After the October fixes (16 GB builders, local NVMe, zstd, no re-clone) and buildx v0.39 on 12 November, the same benchmark on 13 November put Qovery at 0.86x to 0.90x of GitHub's time on Python, Next.js and large-image builds, and on par for Node.js, React and PHP. A near-empty build is still slower, at 1.29x. The method and fixtures are public in github.com/Astach/qovery-ci-benchmark, and the full story is in Making Qovery builds as fast as GitHub Actions, and then faster.

What it costs

Build minutes count as deployment minutes on Qovery's pricing:

PlanPriceUsersClustersDeployment minutes includedOverage
Free$03, plus unlimited AI agents1 (your own)1,000 a month, hard capNone, deployments pause
Starter$299/month313,000$0.16/minute
Growth$899/month1028,000$0.16/minute
Scale$2,999/monthUp to 25330,000$0.16/minute
EnterpriseCustomCustomUnlimitedUnlimitedIncluded

A Qovery deployment minute above your allowance costs far more than any runner minute in this article. If you push 40,000 build minutes a month, Option 3 only works on a plan that includes them. Qovery saves money by removing the deploy pipeline and the time spent maintaining it, and because a 10-person team usually doesn't need to hire a DevOps engineer to run it. It does not win on the price of a minute.

ARC on EKS vs managed runners vs Qovery: which costs less overall?

The cheapest option per minute is ARC on spot nodes at high utilization. The cheapest option in total depends on who maintains what.

ARC on EKS (self-hosted)Managed runners (Blacksmith, Depot, Namespace)Qovery builds and deploys, tests in GitHub Actions
GitHub minute chargesNone today (self-hosted fee postponed)None for the moved jobsNone for build and deploy; tests still billed
Price per build minute~$0.003 (4 vCPU on demand at full use), more when idle$0.004 to $0.006 for 2 vCPU runners; Depot builds $0.04Included in plan minutes; $0.16 overage
Fixed monthly costEKS $73 plus warm nodes$0 to $250 plan feePlan fee (Free to Enterprise)
Where builds runYour AWS accountVendor machines (Depot Managed: your AWS account)Qovery build workers, or your own cluster
Where the image goesYour registry, your setupYour registry, or Depot/Namespace registryRegistry in your cloud account
Cache across buildsYou build it (volumes, registry cache)Built inRegistry cache, image reuse when inputs match
Deploy to KubernetesYour pipelineYour pipelineBuilt in, with rollback
Preview environment per PRYour pipelineYour pipelineBuilt in
Ops work for your teamHighest (cluster, controller, images, security)Low (one line per workflow)Low (Dockerfile; Qovery runs the rest)
Best forHigh volume, platform team, VPC-only buildsSlow CI, happy with your deploy setupNo one who wants to own the deploy path

Which option should my team pick?

Pick by who will maintain the result. ARC fits a team with build volume in the tens of thousands of minutes and a platform engineer who already runs EKS. Managed runners fit a team whose CI is slow but whose deploy setup works. Qovery fits a team that wants builds and deploys in its own AWS account without anyone owning the pipeline in between.

A few signals I look for on calls:

  • "Our deploy YAML is the scariest file in the repo." That's Option 3. Faster runners won't fix it.
  • "Tests take 25 minutes, deploys are fine." That's Option 2, plus the test-splitting tips in the tuning guide.
  • "Security says builds can't leave our AWS account." ARC, Depot Managed on AWS, or Qovery with builds on your own cluster all satisfy this. Pick by the ops work you accept.
  • "Agents tripled our build count last quarter." Model the second row of my cost table first. If most builds come from agent PRs that also need a preview environment, the preview pipeline is your real cost, which points to Option 3.
  • "We have one platform engineer and they're the bottleneck." Don't give them a runner fleet to babysit.

You can also mix them. A setup I see work well is tests on Blacksmith, Depot or Namespace runners, and image build plus deploy on Qovery.

How do I move the image build and deploy to Qovery without touching my tests?

Keep your test workflow, delete the build-push and deploy jobs, connect the repository to Qovery, and enable auto-deploy and preview environments. Start with one low-risk service, then move the others once you trust the numbers.

  1. Connect your AWS account and create a cluster in the Qovery Console, or install Qovery on an EKS cluster you already run (Kubernetes 1.31+).
  2. Create an environment and add your service from the Git repository and Dockerfile. Copy environment variables and secrets, or connect your secrets manager.
  3. Deploy staging once and compare build time with your current workflow. The step timings in the deployment logs show where the time goes.
  4. Remove the build and deploy jobs from your workflow, along with the ECR login, the deploy role and the kubeconfig step. Keep on: pull_request test jobs as they are.
  5. Turn on preview environments on the staging environment so each pull request gets its own copy.
  6. Decide who triggers production. Either auto-deploy on merge to main, or have a GitHub Actions job call the Qovery CLI after tests pass. The Claude Code, GitHub Actions and preview environments tutorial shows the CLI flow.

Keep the old deploy job for a week behind a manual trigger, so you can switch back if something surprises you.

How do I do this with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills, optionally add the MCP Server, then ask your agent in plain language. These are the only commands you need:

BASH|Agent Skills: one install, every compatible agent (Claude Code, Cursor, Codex, OpenCode, Gemini CLI...)
curl -fsSL https://skill.qovery.com/install.sh | bash

# Project-scoped instead of global
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

# MCP Server for Claude Code: OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
  • The first command installs the Qovery skills (qovery-onboard, qovery-deploy, qovery-preview, qovery-speedup and others) for every compatible agent on your machine. Nothing changes in your cloud yet.
  • The --project variant installs them for the current repository only.
  • The MCP command opens an OAuth login that you approve in the browser. It is read-only by default. Write access needs read_write=true on the URL and a separate setting in the Qovery Console.

Then ask: "deploy this app to my AWS account with Qovery", or "create a preview environment for this pull request with Qovery". The AI agent quickstart and the Claude Code integration page have the details.

Frequently asked questions
How do I build and deploy to my own AWS account without paying for GitHub Actions minutes?

Three ways. Run self-hosted runners on EKS with Actions Runner Controller, which GitHub doesn't bill today. Move jobs to a managed runner service like Blacksmith, Depot or Namespace, which bills you instead of GitHub. Or move the image build and deploy to Qovery, which runs them into your own AWS account from your plan's deployment minutes, while tests stay in GitHub Actions.

Are self-hosted GitHub Actions runners free?

GitHub doesn't charge for self-hosted runner minutes today, and they don't use your included usage. GitHub announced a $0.002 per minute platform charge for March 2026 and then postponed it. You still pay for the machines, the EKS control plane ($0.10 an hour), storage, and the time to keep runners patched and secure.

Is Actions Runner Controller on EKS cheaper than GitHub-hosted runners?

Per minute at high utilization, yes: a 4 vCPU c7i.xlarge on demand is about $0.003 a minute against $0.012 for GitHub's 4-core runner. At low utilization the gap closes, because idle nodes still bill. Add the engineering time for the controller, runner images, privileged Docker builds and caches before you decide.

How do Blacksmith, Depot and Namespace prices compare with GitHub Actions?

In November 2026, Blacksmith charges $0.004 a minute for 2 vCPU with 3,000 free minutes a month, Depot $0.006 a minute for runners and $0.04 for container builds on plans from $20 a month, and Namespace $0.003 a minute for 2 vCPU in overage on plans from $100 a month. GitHub's standard 2-core runner is $0.006. None of the three deploys your app to your cluster.

Is Qovery cheaper than GitHub Actions per build minute?

No. Build minutes count as Qovery deployment minutes, and overage on paid plans is $0.16 a minute. Qovery pays off when it replaces your deploy pipeline, registry setup and preview-environment scripts, and the time to maintain them.

Can I keep my tests in GitHub Actions and use Qovery only for build and deploy?

Yes, that's the setup I recommend most. Tests, linters and scans stay in GitHub Actions or on a managed runner. Qovery builds the image from the same commit, stores it in a registry in your cloud account and deploys it to Kubernetes, with a preview environment per pull request.

Guillaume Da Silva
About the author
Guillaume Da Silva

Guillaume is a Staff Solutions Architect at Qovery. He helps customers troubleshoot production infrastructure and writes about Kubernetes operations, AI agents, and reliable cloud platforms.

Next step

Move the build and the deploy into your own AWS account.

Qovery builds your image, stores it in a registry in your cloud account and deploys it to Kubernetes on AWS, GCP, Azure, Scaleway or your own cluster, with a preview environment per pull request. Keep your tests in GitHub Actions.