The CI/CD Tax

Executive Summary

GitHub Actions' pricing page is a masterclass in making infrastructure look cheap. Linux: $0.006 per minute. That's six-tenths of a cent. Run a build for 10 minutes and you've spent six cents. A startup with 5 engineers pushing 20 CI-triggering commits a day, 5 minutes per build on Linux — do the napkin math and you get about $18 a month. The actual bill for that team, if they ship an iOS app, is a four-figure sum: the worked example below lands at roughly $1,400 a month on macOS compute alone, before Windows matrix builds, artifact storage, and cache-miss minutes are even added.

The gap between the per-minute rate and the invoice is not fraud. It's not even particularly hidden. It's five charging dimensions that the pricing page relegates to footnotes, and that most teams discover only after the first monthly invoice triggers a Slack message from finance. They are: the OS multiplier that makes macOS cost 10-40x Linux; the cache miss that turns a sub-minute install into a multi-minute one; the concurrency queue that doesn't appear on the CI bill at all but costs engineering hours and deployment velocity; the artifact and log storage that compounds silently month over month; and the per-job overhead that makes matrix strategies and Docker layer caching cost money per job, not per minute.

This briefing runs the real numbers for all three major platforms — GitHub Actions, GitLab CI, and CircleCI — using September 2026 pricing. It quantifies each tax, gives you the self-hosted break-even formula, and ends with a 5-step audit you can run against your own pipeline this afternoon.

The OS Multiplier: Why Your iOS Build Budget Dwarfs Your Web Build Budget

Here is the part nobody reads in the GitHub Actions docs: macOS minutes cost roughly ten times Linux minutes — $0.062/min versus $0.006/min — and macOS usage burns through your included monthly quota far faster than Linux. It's not a markup. It's physics — Apple silicon doesn't virtualize the way x86 Linux does, and every macOS runner is a physical Mac sitting in a data center somewhere, depreciating whether you use it or not.

Let's put this in real terms. A typical iOS build — compile, run tests, produce an IPA — takes 25 minutes on a 3-core GitHub macOS runner. Cost per build: 25 × $0.062 = $1.55. A team that runs CI on every pull request and merges 15 times a day, with 2 builds per PR (one on push, one on merge), runs roughly 600 builds a month. That's $930/month just for macOS compute. If they also run nightly releases and UI tests, add another 300 builds: $465. Total macOS: $1,395/month. The equivalent Linux pipeline for the backend service — same commit cadence, 5-minute builds — costs 600 × 5 × $0.006 = $18/month. The iOS build is 77x more expensive.

Stack the rest of the stack on top and the figure climbs fast. A Windows desktop client verified on the same cadence adds 600 × 15 minutes × $0.010 = $90. A Linux backend running x64 and ARM64 matrices adds 600 × 5 × $0.006 plus 600 × 5 × $0.005 = $33. Retained artifacts and logs beyond the 500 MB free tier run about 80 GB × $0.25 = $20 (the math is in the storage section). Total: $1,395 (macOS) + $90 (Windows) + $33 (Linux) + $20 (storage) = roughly $1,540 a month — more than 80x the $18 the per-minute napkin math promised. That is the CI/CD tax in one worked example.

CircleCI makes this look reasonable by comparison. Their macOS M4 Pro Medium runner burns 200 credits per minute. At $0.0006/credit, that's $0.12/min — nearly double GitHub's rate. The M4 Pro Large is 400 credits/min, $0.24/min. A 25-minute iOS build on CircleCI M4 Pro Medium costs $3.00. At 600 builds/month: $1,800. GitLab applies a cost factor of 6x to 12x for macOS shared runners depending on the machine class, on top of their $0.010/min base rate for extra minutes.

The escape hatch is self-hosted macOS, but it's not the bargain it looks like on paper. AWS EC2 Mac M1 (mac2.metal) costs roughly $1.05/hour, or $756/month if you run it 24/7. GitHub macOS at $0.062/min is $3.72/hour — so the EC2 Mac is cheaper after 203 hours of build time per month, about 6.8 hours a day. But you can't turn off a bare-metal Mac instance the way you can an EC2 VM; it has a 24-hour minimum allocation. And you're on the hook for Xcode updates, disk cleanup, and runner version management. For a team doing 4+ hours of macOS builds a day, a Mac Stadium dedicated machine (roughly $99-199/month for a Mac mini as of September 2026) often beats both cloud options.

The Cache Miss: When 20 Seconds Becomes 6 Minutes

CI caching is the most impactful cost optimization nobody owns. It's also the least understood. Here's what actually happens: your workflow has a step that restores node_modules from cache. The cache key is node-modules-${{ hashFiles('package-lock.json') }}. If the lockfile hasn't changed and the cache entry exists under GitHub's 10 GB per-repository limit and hasn't expired (7 days since last access), the restore takes 15 seconds and npm install sees everything already there. Total install time: 20 seconds.

Now change one dependency. The hash changes. The cache key misses. npm install downloads 400 packages, runs postinstall scripts, compiles native modules: 6 minutes instead of seconds. At $0.006/min Linux, that's $0.036 cold versus $0.006 warm — a 6x jump — once you account for GitHub rounding every job up to the nearest whole minute (a 20-second install still bills as one full minute). On macOS with CocoaPods, the gap is uglier: pod install with a warm cache finishes in well under a minute; cold, it downloads and compiles 30 pods and takes 12 minutes. At $0.062/min, that's $0.744 versus $0.062 per build.

It gets worse in monorepos. GitHub Actions caps total cache storage at 10 GB per repository. A monorepo with 6 services, each with its own node_modules cache entry of 1.5 GB, uses 9 GB. Add a Go build cache (2 GB) and you're over the limit. GitHub evicts the least-recently-used entry. The next build for the evicted service misses cache, takes 8 minutes, and pushes out another service's cache. Cache thrashing sets in — every build misses something, and average build time drifts upward without anyone noticing until the monthly report.

CircleCI adds insult to injury: Docker layer caching costs 200 credits per job ($0.12), regardless of whether the cache actually hits. If you have 10 jobs in a workflow and 3 of them don't even use Docker, you're paying $0.36/run for a feature that partially works. The pragmatic fixes: split caches by language and lockfile hash so one dependency bump doesn't invalidate everything; use restore-keys prefixes to fall back to a parent cache; and for self-hosted runners, run a local pull-through cache (Verdaccio for npm, Athens for Go, goproxy.cn-style) that never expires and isn't subject to the 10 GB cap.

The Concurrency Queue: The Cost That Doesn't Show Up on the Bill

This one is invisible in the CI invoice, which is why it's the most expensive tax of all. Every CI platform caps concurrent jobs. GitHub caps them by plan — Free allows 20 concurrent jobs, Pro 40, Team 60, and Enterprise 500 — while standard macOS runners top out at 5 concurrent jobs. GitLab Free allows 4 (and you share them with every project in the namespace), CircleCI Free allows 2-4 containers depending on the plan. When your team opens 8 pull requests before lunch and each triggers 3 jobs, you have 24 jobs queued against 20 slots. Four jobs wait.

A 5-minute wait doesn't sound like much. But it's 5 minutes where the engineer who opened the PR is context-switching — checking Slack, reading email, starting another task. When the CI finally goes green 12 minutes after they pushed, they've lost their flow state and need 5-10 minutes to reload the problem. Interruption research for knowledge workers consistently lands in the 15-25 minute range for full refocus after a switch. If queueing adds one such switch per engineer per day, that's 5 engineers × 22 working days = 110 interruptions a month — conservatively 28 to 46 hours of lost deep work. Using a simplified $72/hour engineering-cost assumption, that's $2,000-3,300/month — more than the entire CI bill for most teams.

There's a second-order cost too: deployment latency. If your main branch build is queued behind 6 PR builds, the hotfix you merged at 2:47 PM doesn't reach production until 3:05 PM. For an e-commerce team, that's 18 minutes of a bug being live. For a SaaS team, it's 18 minutes of customer tickets. The Error Budget calculator can help you quantify how deployment latency eats into your availability SLO.

The fixes are structural, not financial. Use concurrency: groups in GitHub Actions to cancel superseded builds on the same branch — if you push twice to a PR, the first build cancels automatically. Use path filters to skip CI when only docs changed. Move long-running jobs (integration tests, nightly releases) to a separate workflow that doesn't block PR checks. And if you're consistently hitting the concurrency cap, that's the signal to either upgrade the plan or add a self-hosted runner — the queueing cost is already higher than the upgrade fee.

The Artifact & Storage Drag: The Line Item That Grows While You Sleep

Build artifacts are the cockroaches of CI costs — small, numerous, and impossible to fully eliminate. Every build produces something: a compiled binary, a test coverage report, a Docker image, a log file. GitHub Actions gives you 500 MB of free artifact storage per month and charges $0.25/GB beyond that. GitLab includes 10 GB on Free and 50 GB on Premium. CircleCI gives 2 GB free and charges for more. None of them sound like real money — until you realize artifacts accumulate.

Consider a team that produces a 150 MB test coverage report and a 300 MB Docker image per build, at 60 builds/month. That's 27 GB/month of new artifacts. If retention is set to the default (90 days on GitHub), at any given time you're storing 81 GB. Beyond the 500 MB free tier: 80.5 GB × $0.25 = $20.13/month. Not catastrophic. That artifact-storage figure is separate from your container registry, which bills on its own: GitHub Packages (GHCR) charges $0.005/GB/month for image storage and $0.005/GB for data transfer out. A 2 GB image pulled 500 times/month by Kubernetes nodes is 1 TB of egress = $5/month, on top of the storage itself. Logs are the sleeper: GitHub stores workflow logs for 90 days by default, and a verbose build can generate 50-200 MB of logs per run. At 60 runs/month, that's 3-12 GB of logs alone.

The compounding effect is what catches teams. Artifact storage grows linearly with build count. Build count grows with team size. Team size grows with revenue. By the time a startup reaches 20 engineers, they're often storing 200-500 GB of CI artifacts and logs at $50-125/month. It's never the largest line item, but it's also never optimized — because nobody owns it. The fix is mechanical: set artifact retention to 7-14 days for PR builds (you almost never need a PR artifact after merge), keep release artifacts for 90 days, and enable log retention policies. Use the Log Storage Cost calculator to model what your retained logs actually cost.

The Per-Job Overhead: Matrix Builds and the Fixed Cost of Every Step

Every CI job has a fixed cost that has nothing to do with how long your tests take. On GitHub Actions, each job spins up a fresh runner: provision the VM, pull the actions, checkout the code, set up the language toolchain. That's 30-90 seconds of overhead per job, billed at the per-minute rate (rounded up). On CircleCI, Docker layer caching costs 200 credits per job regardless of duration. GitLab's shared runners apply cost factors that scale with machine class — a 4x machine doesn't just run faster, it bills at 4x the minute rate.

Matrix strategies expose this overhead brutally. A test matrix of node-version: [18, 20, 22] × os: [ubuntu-latest, windows-latest] = 6 jobs. If each job has 60 seconds of fixed overhead and 2 minutes of actual testing, you're paying 6 × 3 minutes = 18 minutes billed, of which 6 minutes (33%) is pure overhead. On Windows ($0.010/min) that overhead is more expensive. Add a third dimension — database: [postgres, mysql] — and you're at 12 jobs, 12 minutes of overhead, and the actual test time hasn't changed at all.

GitHub proposed a $0.002 per-job control plane fee in late 2025, then postponed it indefinitely after community backlash. But the overhead exists regardless of whether it's itemized: runner provisioning time is billed compute time, and it scales with job count, not build duration. A workflow with 15 tiny jobs (lint, typecheck, unit test per package, build per service) will always cost more than a workflow with 3 jobs that do the same work, even though the total test execution time is identical.

The Self-Hosted Break-Even: When to Stop Paying by the Minute

At some volume, renting runners by the minute becomes more expensive than owning them. The break-even math is straightforward but depends entirely on which OS you're building for.

Linux. A 4-core 8 GB virtual machine from Hetzner (CX42) costs €21/month (~$23). DigitalOcean's equivalent is $48. GitHub Actions 4-core Linux costs $0.012/min. At $30/month for a VM, the raw-compute break-even is 2,500 minutes/month — about 83 minutes a day, or roughly 17 five-minute builds. A team with more than a handful of engineers clears this on raw compute alone. The catch is that the true break-even sits higher once you add maintenance: runner version updates, disk space management (Docker images fill disks fast), and security patching. Figure 2-4 hours of engineer time per month. For a team already running Kubernetes, adding an Actions Runner Controller (ARC) deployment is a one-day project and gives you auto-scaling self-hosted runners at marginal cost.

macOS. As noted earlier, EC2 Mac M1 is ~$1.05/hour ($756/month always-on), GitHub macOS is $3.72/hour equivalent. Break-even at 203 hours/month. But the 24-hour minimum allocation means you can't spin it down on weekends. Mac Stadium dedicated Mac minis start at $99/month and are often the cheapest option for steady macOS CI — but you're responsible for the full software stack. For teams under 4 hours of macOS builds per day, hosted GitHub macOS is still cheaper than self-hosted once you count the Mac's idle time and maintenance overhead.

Windows. GitHub Windows 2-core is $0.010/min. A Windows VM in the cloud costs $30-60/month. Break-even at 3,000-6,000 minutes/month. Most teams don't have enough Windows builds to justify self-hosting, and Windows runner maintenance (updates, antivirus, disk bloat) is more painful than Linux.

Concrete Steps: The Pipeline Audit

1. Pull your actual CI spend by OS and workflow, not the per-minute estimate. GitHub's billing page shows total Actions minutes but not by OS. Use the Actions usage API (/repos/{owner}/{repo}/actions/timing) or a tool like ci-spend to get per-workflow, per-OS breakdown. You're looking for one number: what percentage of your bill is macOS. If it's over 50% and you're not primarily an iOS company, you have a problem.

2. Audit cache hit rates across every workflow. GitHub Actions doesn't show cache hit rate in the UI by default. Add a step that checks if the cache key was restored and logs it, or use the Actions cache API. Any workflow below 80% cache hit rate is costing you 2-5x more than it should. Fix the cache keys (use lockfile hashes, not branch names), split large caches, and delete stale cache entries via the API to free up the 10 GB limit.

3. Set artifact and log retention to 14 days for PR builds. The default is 90 days on GitHub. You will never look at a PR build's artifacts 15 days after the PR merged. Change it in the repo settings or via retention-days in the workflow. This alone typically cuts artifact storage by 70%.

4. Add concurrency groups to cancel superseded builds. Every PR workflow should have concurrency: group: ci-${{ github.ref }}, cancel-in-progress: true. If you push twice to a branch, the first build cancels. For a team that pushes frequently, this cuts total build minutes by 20-40% with zero quality loss.

5. Consolidate jobs under 2 minutes. Walk through your workflow YAML. Any job that runs in under 2 minutes is paying 30-90 seconds of overhead for 30 seconds of work. Merge it into an adjacent job. A workflow that goes from 12 jobs to 6 jobs with the same total test time will cost 20-30% less.

Frequently Asked Questions

Methodology & Disclosure

Pricing data is based on publicly available rate cards accessed in September 2026. GitHub Actions: Linux 2-core $0.006/min (post-January 2026 reduction), Linux 1-core slim $0.002/min, Linux ARM64 $0.005/min, Windows 2-core $0.010/min, macOS $0.062/min. Free tier: 2,000 minutes/month for private repos (Team: 3,000), unlimited for public repos. macOS minute multiplier: roughly 10x the Linux rate against free quota. Cache limit: 10 GB/repo, 7-day inactivity expiry. Artifact storage: 500 MB free, $0.25/GB beyond. GitLab CI: Free 400 min/mo, Premium ($29/user/mo annual) 10,000 min/mo, Ultimate 50,000 min/mo. Extra minutes: $10/1,000 ($0.010/min). macOS cost factor: 6x-12x depending on runner class. CircleCI: Free 30,000 credits/mo, Performance $15/mo + 30,000 credits/user. Linux medium: 10 credits/min ($0.006). macOS M4 Pro Medium: 200 credits/min ($0.120). macOS M4 Pro Large: 400 credits/min ($0.240). Docker layer cache: 200 credits/job. Network egress: 420 credits/GB. Self-hosted infrastructure pricing: Hetzner CX42 €21/mo, DigitalOcean s-4vcpu-8gb $48/mo, AWS EC2 Mac M1 (mac2.metal) ~$1.05/hr, Mac Stadium Mac mini from $99/mo. All break-even calculations assume 730 hours/month and do not include engineer maintenance time.

Disclosure: jslet is an independent research project. This analysis was produced using publicly available pricing data and our own vCPU to Core Hours calculator. We are not sponsored by GitHub, GitLab, CircleCI, or any cloud provider, and we have no financial relationship with any vendor discussed in this article.

References & Further Reading

1. GitHub (2026). "Actions runner pricing." Per-minute rates for Linux, Windows, macOS, and ARM runners. docs.github.com
2. GitHub (2026). "GitHub Actions billing." Free minutes, minute multipliers, artifact storage, and cache limits. docs.github.com
3. GitLab (2026). "Compute minutes." Quota tiers, cost factors, and overage pricing for shared runners. docs.gitlab.com
4. CircleCI (2026). "Credit pricing." Per-resource-class credit consumption, Docker layer caching, and network egress charges. circleci.com
5. AWS (2026). "Amazon EC2 Mac instances." Pricing and minimum allocation for mac1/mac2/mac3 metal instances. aws.amazon.com
6. GitHub (2026). "Caching dependencies to speed up workflows." Cache storage limits, eviction policy, and cache key best practices. docs.github.com
7. GitHub (2026). "Using concurrency." Canceling superseded workflow runs and concurrency groups. docs.github.com
8. jslet Research (2026). "The Observability Tax: Why Your Logs Cost More Than Your Servers." Companion analysis on log storage and retention economics. jslet.com

📜 Copyright & Attribution

📡 Enjoyed this? When the pricing page shows $0.006/minute and your bill shows eighty times that, the difference is a product of five billing dimensions the pricing page excludes. RSS covers one pricing-structure reality check per week. No vendor sponsors. No tracking. RSS Feed → | More options →