If a GitHub Actions job stays on "Queued" for more than a minute or two, something specific is holding it. It's usually one of seven things, and adding runners only fixes some of them.
Below is each cause, how to spot it, and what to change. Get real numbers first, because the Actions UI doesn't show you queue time.
Before anything: measure the wait
The API has what you need. Every job has a created_at (when it was queued) and a started_at (when a runner took it). The difference is your queue time.
This lists the jobs that waited longest across your last 30 runs:
OWNER=your-org
REPO=your-repo
gh api "repos/$OWNER/$REPO/actions/runs?per_page=30" --jq '.workflow_runs[].id' |
while read -r run; do
gh api "repos/$OWNER/$REPO/actions/runs/$run/jobs" --jq '
.jobs[] | select(.started_at != null and .runner_name != null)
| [((.started_at | fromdate) - (.created_at | fromdate)), (.labels | join(",")), .name]
| @tsv'
done | sort -rn | head -20
The output looks something like this (seconds waited, labels, job name):
725 macos-15,xlarge build-ios
270 ubuntu-latest test (ubuntu)
Two things to look for:
- Which labels wait. Only macOS jobs waiting is a different problem from everything waiting.
- When they wait. Waits during busy hours point to a limit. A job that never starts points to a runner that does not exist.
The runner_name filter matters. Skipped jobs (from an if: that was false) never get a runner and show up as zero wait, which pulls your numbers down. Jobs that are still waiting also have an empty runner_name.
For a sense of what normal looks like: on a busy private monorepo I checked, 105 jobs over about 16 hours on ephemeral Linux VMs had a median wait of 13 seconds and the slowest took 21. If your median is measured in minutes, one of the causes below is in play.
1. You hit your plan's concurrent job limit
GitHub-hosted runners have a cap on how many jobs your account can run at the same time. Jobs over the cap wait their turn. These are the numbers from GitHub's Actions limits page as of November 2026:
| Plan | Concurrent jobs | Concurrent macOS jobs |
|---|---|---|
| Free | 20 | 5 |
| Pro | 40 | 5 |
| Team | 60 | 5 |
| Enterprise | 500 | 50 |
A test matrix of 4 Node versions x 5 test shards is 20 jobs. Add lint and build and one push uses 22 slots, so two pushes at the same time on the Team plan get you close to 60. Coding agents that open pull requests on their own make this worse, since each one triggers the full set.
Ways to get under the limit:
- Cancel superseded runs. If you push three commits to a pull request within a minute, only the last result matters. The config is in cause 3.
- Run one Node version on pull requests and the full matrix on
mainor nightly. - Merge very short jobs. A 10 second lint job still takes a slot and a full runner boot.
- Ask GitHub Support. They can raise concurrency limits on paid plans.
- Move heavy jobs to runners outside this cap. Self-hosted and third-party runners have their own limits, and some don't cap concurrency at all (WarpBuild doesn't on Linux and Windows). For queue time, that limit matters more than CPU speed or price per minute.
2. macOS has a much smaller limit
Look at the macOS column again: 5 concurrent macOS jobs on Free, Pro and Team. GitHub also says this limit is shared between standard and larger macOS runners, so paying for bigger Macs does not give you more slots.
An iOS team with a build job, a unit test job and a couple of simulator test jobs fills that with one push. GitHub's own macOS capacity also runs short at times. Its status page has had incidents where macOS arm64 capacity dropped and jobs queued for hours, and GitHub warns that capacity shrinks for images close to retirement (macOS 14 right now). In those cases jobs wait even when you are under your own limit.
For macOS specifically:
- Keep non-Mac work off Macs. Linting, formatting and Swift package checks that don't need Xcode can usually run on Linux.
- Run the full simulator suite before merge, not on every push. A label or a path filter is enough.
- When you compare macOS runner options, ask about concurrency before price. Five fast Macs at a time still means a queue. The concurrency number is often not on the pricing page, so you may have to ask.
3. Your own concurrency group is holding the job
This one comes from your workflow file, not from GitHub's capacity. If a job joins a concurrency group that already has a run in progress, it waits (GitHub shows it as "pending"). By default only one run can wait per group, and a newer run replaces it.
For pull request checks, cancel the old run when a new commit comes in:
concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
cancel-in-progress: true
github.head_ref only exists on pull_request events. The run_id fallback gives pushes to main their own group, so they never cancel each other.
For deploys, you usually want runs to wait in order instead:
concurrency:
group: deploy-production
queue: max
queue: max lets up to 100 runs wait in the group. You can't use it together with cancel-in-progress: true. GitHub will reject the workflow.
Watch out for a group name with no branch in it, like group: ci. Every branch then waits for every other branch, which looks like a capacity problem but isn't.
4. No runner matches the labels
A job only starts on a runner that has all of its runs-on labels. If none is online, the job doesn't fail. It stays on "Waiting for a runner to pick up this job...", and for self-hosted runners GitHub cancels it after 24 hours.
How this usually happens:
- A typo or an old label. The workflow says
linux-arm64, the runner was re-registered asarm64-linux. - One extra label that no online runner has, like
[self-hosted, linux, gpu]while the GPU machine is down. - The runner group doesn't allow this repository.
- A larger runner label copied from another organization's workflow.
To check, compare the labels from the script output with Settings > Actions > Runners, and check which repositories the runner group allows.
5. Your self-hosted runners can't keep up
If you run your own runners, the queue is your own capacity. The usual reasons:
- Fewer runners than you need at peak.
- Long-lived runners stuck on an old job, or offline after an OS update.
- Autoscaling that only starts a machine after a job is queued, so every job waits for a VM or pod to boot.
Keep a few warm runners during working hours, use ephemeral runners so one broken machine doesn't block the next job, and run the script above before and after each change so you know it helped.
If you want the runners in your own cloud account but don't want to run the autoscaling yourself, there's a middle ground: a managed service that starts ephemeral VMs inside your AWS, GCP or Azure account. Several runner providers offer this, and WarpBuild calls it BYOC. You still pay your cloud bill, but someone else deals with scaling, images and broken runners.
6. It's waiting for something that isn't a runner
Some states look like a queue but more runners won't fix them:
-
needs:: the job is waiting for another job to finish first. - Environment rules: required reviewers or a wait timer on an environment hold the job.
- First-time contributors: on public repositories, workflows from new contributors can need a maintainer's approval before they run.
Check the job's environment and the approval banner on the run before you spend money on capacity.
7. GitHub is having an incident
If everything is queued across all your repositories at once, and nothing changed on your side, check githubstatus.com before you change anything.
Quick lookup
| What you see | Likely cause |
|---|---|
| Everything waits at busy times, then clears | 1. Plan limit |
| Only macOS jobs wait | 2. macOS limit or capacity |
| A run is "pending" behind another run of the same workflow | 3. Concurrency group |
| One label never starts | 4. Labels or runner group |
| Self-hosted jobs wait in bursts | 5. Not enough runners |
| Waiting with an environment or approval message | 6. Not a runner problem |
| Every repository waits at once | 7. GitHub incident |
A few caveats
GitHub changes these limits from time to time, so check the linked page before you plan around the table. And cancelling old runs saves slots, but you lose results for the commits in between. If you need a result for every commit, use queue: max or skip the concurrency group.
Top comments (0)