Qovery vs GitHub Actions for building and deploying containers: build times measured, pipelines compared
A buyer's comparison of GitHub Actions and Qovery for building Docker images and deploying them to your own AWS account: our public benchmark against ubuntu-latest, every piece a GitHub Actions pipeline needs to reach a running service, real 2026 prices, and when GitHub Actions is the better pick.
On our public benchmark of 13 November 2026, Qovery builds are as fast as GitHub Actions' ubuntu-latest runner on typical apps and faster on heavier ones. Python, Next.js and a 2.5 GB image finish at 0.86x to 0.90x of GitHub's time. Node.js, React and PHP sit at 1.00x to 1.08x. In September, Qovery was 1.4x to 3.6x slower, and we published that too.
A GitHub Actions pipeline that ends with a running service on AWS needs six things besides the build: a registry, AWS credentials (OIDC), cluster access, a deploy job, environments with approvals, and a preview and rollback story. You write and maintain each one in YAML.
Qovery does the build, the push to a registry in your cloud account, the Kubernetes deploy, per-pull-request preview environments and rollback in one product, on your own AWS, GCP, Azure or Scaleway account, or on a cluster you already run.
GitHub Actions is the better choice if you only need CI, if you deploy to something that is not a long-running container service, or if your team already owns a working deploy pipeline and nobody complains about it.
Many teams use both. Tests stay in GitHub Actions (or on a faster runner), and Qovery builds the deploy image and ships it.
Most of our customers already use GitHub Actions. So when they evaluate Qovery, the first question they ask is "why would I move my Docker build out of GitHub Actions, and is Qovery even as fast?"
Until October, my honest answer to the second half was "no". Some customers moved their image builds back to GitHub Actions and used Qovery only to deploy. We fixed that, measured it on a public benchmark, and told the engineering story in Making Qovery builds as fast as GitHub Actions, and then faster. This article is the buyer's version. If you run a 10-person team shipping containers to your own AWS account, here is what each option costs you in time, in YAML and in dollars, and when you should stay with GitHub Actions.
How fast are Qovery builds compared with GitHub Actions' ubuntu-latest runner?
On 13 November 2026, Qovery took between 0.86x and 1.29x of GitHub Actions' time to build the same Docker images, measured from checkout to image in the registry. Heavier builds (Python, Next.js, a large image) are 10% to 14% faster on Qovery, typical apps are on par, and a near-empty build is still slower.
The benchmark is public: github.com/Astach/qovery-ci-benchmark. It has seven fixtures that look like what our customers deploy: an empty build, an Express/TypeScript API, a FastAPI service with native wheels, a Vite/React front end, a Next.js standalone app, a PHP app with Composer and Vite, and an image with a final layer of about 2.5 GB. On the GitHub side, every build runs on the standard ubuntu-latest runner with Docker Buildx. No cache, median of three runs, 4 CPU and 16 GB on both sides. Anyone can rerun it.
Here is how we got from "slower everywhere" to this table, in three dates:
September 2026: Qovery was 1.4x to 3.6x slower than ubuntu-latest on every fixture. The gap was biggest on small builds, so it was mostly fixed overhead.
October 2026: builders went from 8 GB to 16 GB of RAM, builder nodes moved to local NVMe disks, images and build cache switched to zstd, and the engine stopped re-cloning a repository when the image already exists. Across all customer builds, the median build went from about 3 minutes to under 1.5 minutes, and the 95th percentile from about 11.5 to about 6 minutes.
12 November 2026: we moved to buildx v0.39, which Docker released on 11 November with a startup probe fix (docker/buildx#4124). That removed a wait of about 26 seconds on every build. Every fixture got 22 to 37 seconds faster than in October.
On a cold build of the large image, Qovery took 149 seconds against 181 seconds on GitHub Actions. On the empty build, a few seconds of fixed overhead still weigh a lot in a 20-second job, and that is the next thing we are fixing.
What this benchmark does not measure
The timer stops when the image is in the registry. It does not include the deploy, so I am not going to give you a "commit to running service" number for either side today. We will publish that next, because on Qovery the build and the deploy run in the same product and there is no handoff to time.
It also says nothing about Blacksmith, Depot, Namespace or GitHub's larger runners. We have not benchmarked against them, and I would not trust anyone who claims a win without a public test.
What is faster than ubuntu-latest for Docker image builds?
Four things beat a standard 2-core hosted runner on build speed: a bigger GitHub runner, a managed runner service with a persistent cache (Blacksmith, Depot, Namespace), a self-hosted runner with a warm local cache, or a build service that sits next to your deploy target, which is where Qovery fits. Which one wins depends on whether you only want a faster build or a shorter path to a running service.
Their speed claims are their own. Blacksmith's pricing page says "2x faster", and Depot's site says its container builds are "up to 40x faster". I have no reason to doubt that these teams build fast machines, but I can only vouch for numbers I can rerun.
A larger GitHub runner only pays off when your build uses the cores. An 8-core runner costs 3.7 times a 2-core one, so the job must finish 3.7 times faster to cost the same. Dependency installs and registry pushes rarely scale that way.
What does a GitHub Actions build-and-deploy pipeline to AWS need?
To go from a commit to a running container on EKS with GitHub Actions, you need a registry, an AWS role your workflow can assume through OIDC, cluster access for that role, a build job, a deploy job, environments with approval rules, and a plan for previews and rollback. GitHub Actions gives you the runner and the workflow engine. Every other piece is yours to write and keep working.
Here is a trimmed but realistic workflow for one service:
That file looks short. Each line hides work somebody on your team owns:
A container registry. An ECR repository per service, a lifecycle policy so it doesn't grow forever, and image scanning if you want it. ECR storage is $0.10 per GB-month (AWS).
Credentials without long-lived keys. OIDC needs an identity provider in IAM, a trust policy scoped to your repository and branch, and id-token: write in the workflow (GitHub docs). Two roles if you separate build and deploy, which you should.
Cluster access. The deploy role needs an EKS access entry or an aws-auth mapping and Kubernetes RBAC, scoped to the namespaces it may touch.
A deploy job and a chart. Helm values, manifests or Kustomize overlays per environment, health checks, and --atomic or an equivalent so a failed rollout reverts.
Environments and approvals. GitHub environments give you scoped secrets and protection rules, but required reviewers on private repositories are only available on GitHub Enterprise. On Free, Pro and Team plans, they work on public repositories only (GitHub docs).
Previews and rollback. A preview per pull request means a namespace per PR, a database for it, a URL, DNS, TLS, and a cleanup job when the PR closes. Rollback means redeploying a previous image tag and knowing which one was good.
Then multiply by your services. A 10-person team with an API, a worker, a front end and a cron job has four of these, plus a staging copy. None of it is hard on its own. The cost is that it is yours forever, and the person who wrote it is usually the one person who understands it.
I have interviewed more than 200 CTOs, and teams of 5 to 20 engineers tell me the same story. The build works fine. The YAML and IAM around it is what hurts, because one engineer maintains it on Friday afternoons.
Build and deploy from one place, in your own AWS account.
Qovery builds your image, pushes it to a registry in your cloud and deploys it to Kubernetes on AWS, GCP, Azure, Scaleway or your own cluster, with a preview environment per pull request. Free for 3 users and unlimited AI agents.
Qovery builds the image from your Git repository, pushes it to a registry in your own cloud account, deploys it to Kubernetes in that account, and handles environments, preview environments per pull request and rollback from the same product. You connect a repository and push.
Here is how the six pieces above map:
Build. Qovery builds from your Dockerfile. By default, builds run on a pool of build workers on Qovery's side, in a Kubernetes cluster dedicated to builds. You can also run builds on your own cluster. Step timings show in the deployment logs, and the Build Optimizer reads your Dockerfile, logs and cache history and proposes a corrected Dockerfile (live since 12 November for a first group of customers).
Registry. The built image goes to a mirroring registry in your cloud account, and Qovery skips the build entirely when an image with the same inputs (commit, Dockerfile, build arguments) already exists (Qovery docs).
Credentials and cluster access. You connect your AWS account once. Qovery creates and manages the EKS cluster for you, or installs on a cluster you already run. No per-repository OIDC roles, no kubeconfig in CI.
Deploy. Rolling updates by default, with automatic rollback if the new version fails to start (Qovery docs), and a deployment history you can roll back from.
Environments. Production, staging and any other environment are clones of each other, with RBAC per environment and audit logs of who deployed what.
Previews. Turn on preview environments on a blueprint environment, and every pull request gets its own full-stack copy, redeployed on every commit and deleted when the PR closes (Qovery docs).
Qovery is an Agentic DevOps platform, and it never hosts your apps. The control plane runs on Qovery's side, while your apps, databases and images stay in your AWS, GCP, Azure or Scaleway account, or on your existing Kubernetes cluster. Your cloud bill, your credits and your Savings Plans stay in your name.
Qovery vs GitHub Actions for a 10-person team on AWS: how do they compare?
For a 10-person team shipping containers to its own AWS account, GitHub Actions is the cheaper and more flexible CI engine, and Qovery is the shorter path from commit to a running, previewable service. The table below compares them on the jobs a team needs done.
Job to be done
GitHub Actions (with EKS and ECR you set up)
Qovery
Run tests and linters on every PR
Yes, its core strength
Not the goal; keep tests in GitHub Actions
Build the Docker image
Yes, on ubuntu-latest or a larger runner
Yes, as fast as ubuntu-latest on typical apps, 0.86x to 0.90x on heavier builds (benchmark)
Store the image
You create ECR repos and lifecycle rules
Registry in your cloud account, unused images cleaned up
Skip rebuilding an identical image
You build the logic (tags, cache keys)
Built in: same inputs, no rebuild
Authenticate to AWS
OIDC provider, IAM roles, trust policies
Cloud account connected once
Deploy to Kubernetes
Your Helm/kubectl job, your chart
Built in, rolling update with automatic rollback on failed start
Staging and production
GitHub environments plus your own manifests
Cloned environments with per-environment RBAC
Approval before production
Required reviewers on private repos need GitHub Enterprise
RBAC on who can deploy to which environment
Preview environment per PR
You build it (namespace, DB, DNS, TLS, cleanup)
Built in, deleted when the PR closes
Rollback to a known good version
Redeploy an old tag by hand or script
From the deployment history
Who maintains the pipeline
Someone on your team
Qovery; you maintain your Dockerfile
Scoped access for AI agents
Repository and workflow permissions
API Policy Tokens (OPA) scoped per agent, MCP server read-only by default
Qovery does not try to replace GitHub Actions as a test runner, and you should not ask it to. And a lot of the "you build it" cells are things a strong platform engineer does in a week. That only helps if a 10-person team has that engineer and wants them doing it.
What does each option cost a 10-person team?
GitHub Actions minutes are cheap: a 2-core Linux runner costs $0.006 a minute, a 4-core $0.012, and every job is rounded up to the next whole minute (GitHub). Team plans include $18 of compute a month, larger runners require the Team plan or above, and Team allows 60 concurrent jobs (GitHub limits). For most 10-person teams, the minutes bill for Docker builds is tens to low hundreds of dollars a month.
So I won't tell you Qovery is cheaper per build minute. It isn't. On Qovery's pricing, build minutes count as deployment minutes. Growth is $899 a month for 10 users, 2 clusters and 8,000 deployment minutes, and overage is $0.16 a minute, well above any runner in the table above. The Free plan gives 3 users, unlimited AI agents, one cluster of your own and 1,000 deployment minutes a month, with no credit card.
Where Qovery saves money:
One pipeline fewer. No separate deploy workflow, no Helm chart per service, no OIDC roles per repository, no preview-environment scripts.
Fewer rebuilds. Qovery skips the build when an image with the same inputs already exists.
No dedicated DevOps hire for the deploy path. For a team of 10, that is the line that moves the budget, and it is the reason our customers give for staying.
If you already have a working deploy pipeline that nobody fights with, the math favors keeping it.
When is GitHub Actions the better choice?
GitHub Actions is the better choice when you need CI and not a deploy platform, when what you ship is not a long-running container service in your cloud, or when your team already owns a deploy pipeline that works. In those cases, adding Qovery adds a tool without removing one.
Pick GitHub Actions (and maybe a faster runner) if:
You ship libraries, mobile apps, CLIs or desktop builds. You publish artifacts, not services. Qovery has nothing to deploy.
Your production target is not Kubernetes or containers in your cloud. Static sites on a CDN, Lambda functions, or a vendor's PaaS are better served by their own deploy actions.
You have a platform engineer and a mature GitOps setup. If Argo CD or Flux already reconciles your clusters and your team likes it, keep it. We wrote a fair comparison for that case: Argo CD vs Qovery for agent PR environments.
Your builds are tiny. On a near-empty build, Qovery is still at 1.29x of GitHub's time. If all your images build in 20 seconds, GitHub Actions is faster today.
You need macOS or Windows builds. Qovery builds Linux container images.
Price per minute is your only metric. GitHub's hosted runners, and Blacksmith, Depot or Namespace, are cheaper per minute than Qovery's deployment minutes.
Can I use GitHub Actions and Qovery together?
Yes, and it is the setup I recommend to most teams. GitHub Actions runs tests, linters and security checks on every pull request. Qovery builds the deploy image from the same commit and ships it to your environments, including a preview environment per pull request.
Delete the build-push and deploy jobs. That removes the ECR login, the deploy role, the kubeconfig step and the Helm chart from CI.
Connect the repository to Qovery and enable auto-deploy on the branch you ship from.
Turn on preview environments on your staging environment so each PR gets its own copy.
If you want GitHub Actions to stay in charge of when a deploy happens, the Qovery CLI can trigger deployments from a workflow step. Our tutorial on Claude Code, GitHub Actions and preview environments shows that flow end to end.
Why does build-to-deploy time matter more with AI coding agents?
Coding agents open pull requests all day, and each one waits on a build and often on a preview environment before anyone can review it. A fixed overhead of 30 seconds was noise when humans pushed a few times a day. Repeated across dozens of agent PRs, it decides how fast your review loop goes.
That is why we track one number now: time from commit to code running in an environment someone can click. A faster runner shortens the build, and the handoffs to a registry, then to a deploy job, then to a cluster stay where they were. Having all of them in one product lets us remove waste between the steps, like skipping a build when the image already exists.
What we are working on next, and have not shipped yet: building an image once and deploying it to many environments, faster CPUs on builders, a build cache that stays on the builder, and moving the cache export off the critical path.
Agents also need guardrails. With Qovery, an agent gets an API Policy Token whose permissions are written in OPA, so it can deploy a preview but not touch production (how policy tokens work). Every action lands in the audit log under that token's name.
How do I hand this to Claude Code or Cursor?
If you want your coding agent to set this up, install the Qovery Agent Skills and, optionally, the MCP Server. 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 skills install adds qovery-onboard, qovery-deploy, qovery-preview, qovery-speedup and the other Qovery skills to your agent. It changes nothing in your cloud.
The --project variant scopes the skills to the current repository instead of your whole machine.
The MCP Server opens an OAuth login in your browser, which you approve. It is read-only by default. Write access needs read_write=true on the URL and a separate setting in the Qovery Console, so only add it when you mean to.
Then ask in plain language: "deploy this app to my AWS account with Qovery", or "create a preview environment for this pull request with Qovery". To check where your build time goes, ask the agent to run the speedup skill on your service. The AI agent quickstart and the Claude Code integration page cover the details.
Frequently asked questions
Should a 10-person team on AWS use GitHub Actions or a build-and-deploy platform?
Use GitHub Actions for tests either way. For build and deploy, a platform like Qovery makes sense when nobody on the team wants to own the registry, OIDC roles, Helm charts, preview environments and rollback scripts around the build. If you already have a platform engineer and a working GitOps pipeline, GitHub Actions plus your existing deploy setup is the cheaper path.
What is faster than GitHub Actions' ubuntu-latest runner for Docker image builds?
GitHub's larger runners, managed runner services with persistent caches (Blacksmith, Depot, Namespace), and self-hosted runners with a warm cache can all beat a standard 2-core runner. On our public benchmark of 13 November 2026, Qovery builds took 0.86x to 0.90x of ubuntu-latest's time on Python, Next.js and large-image builds, and 1.00x to 1.08x on Node.js, React and PHP. We have not benchmarked Qovery against Blacksmith, Depot or Namespace.
What are the best GitHub Actions alternatives for building and deploying Docker apps to our own AWS account?
If you only want faster CI, look at Blacksmith, Depot or Namespace runners, which keep your workflows. If you want the build and the deploy in one place on your own AWS account, Qovery builds the image, stores it in a registry in your account and deploys it to EKS with preview environments and rollback. Our GitHub Actions alternatives list covers CircleCI, GitLab CI, Buildkite and others for the CI side.
Is Qovery cheaper than GitHub Actions?
Not per minute. GitHub charges $0.006 a minute for a 2-core Linux runner, and Qovery's overage is $0.16 per deployment minute on paid plans. Qovery saves money when it replaces a deploy pipeline, preview-environment scripts and the engineering time to maintain them, which matters most for teams without a dedicated DevOps engineer.
Does Qovery replace GitHub Actions completely?
No, and we don't recommend it. Keep tests, linters and security scans in GitHub Actions. Move the image build and the deploy to Qovery so the same product builds the image, pushes it to your cloud's registry, and deploys it to every environment, including a preview per pull request.
Where do Qovery builds run, and where does the image go?
By default, builds run on a pool of build workers on Qovery's side, in a Kubernetes cluster dedicated to builds, and you can choose to build on your own cluster instead. The image is pushed to a registry in your own cloud account and deployed to Kubernetes in that account. Your application never runs on Qovery's infrastructure.
Romaric founded Qovery to make Kubernetes accessible to every engineering team. He writes about platform strategy, developer experience, and the future of cloud infrastructure.
Next step
Build and deploy from one place, in your own AWS account.
Qovery builds your image, pushes it to a registry in your cloud and deploys it to Kubernetes on AWS, GCP, Azure, Scaleway or your own cluster, with a preview environment per pull request. Free for 3 users and unlimited AI agents.