Summary

  • GitLab defines compute minutes with a printed formula, Job duration / 60 * Cost factor, and defines the cost factor as a multiplier that "is not a monetary price".
  • Seven GitLab pages print the divisor, the runner factor table, the 400, 10,000 and 50,000 monthly allowances and the $10 per 1,000 minutes add-on, and none of them prints a billing increment, a rounding rule or a minimum charge.

A ten-minute pipeline can be billed as forty compute minutes, and on GitLab's own terms both figures are correct. The page that produces the second one is public: "Your compute minute usage for each job is calculated using this formula: Job duration / 60 * Cost factor" (Compute minutes). The divisor is sixty. The unit is named after a minute. The multiplier is neither a minute nor money: the same page defines job duration as the seconds a job took to run, created and pending excluded, and defines the cost factor as a number set by runner type and project type that decides how quickly a job consumes compute minutes and "is not a monetary price".

The factor table is printed in full. Linux x86-64 hosted runners score 1 for small, 2 for medium, 3 for large, 6 for xlarge and 12 for 2xlarge; the GPU-enabled medium scores 7; Linux Arm64 scores 1, 2 and 3 at small, medium and large; macOS M1 medium scores 6 and macOS M2 Pro large 12, both Beta; Windows medium scores 1, also Beta. Project type moves the same lever at a different scale: 0.5 for public projects in the GitLab for Open Source program, 0.008 for public forks of those projects, and, for community contributions, a dynamic factor of the monthly compute quota divided by 300,000 job duration minutes.

Seven GitLab pages are cited in this briefing, five on docs.gitlab.com and two on about.gitlab.com, all read on 21 November 2026. Not one of them states how a fractional compute-minute result becomes a billable number. There is no rounding rule, no minimum charge and no statement of per-job granularity anywhere in the seven. By the printed formula, a forty-second job on a small Linux runner is two thirds of a compute minute, by my division; whether the quota records 0.67, 1 or some other number is a fact the published pages do not contain.

The runner names are not machine names, and the machines are printed somewhere else. The small Linux x86-64 runner is 2 vCPU and 8 GB, medium 4 vCPU and 16 GB, large 8 vCPU and 32 GB, xlarge 16 vCPU and 64 GB, 2xlarge 32 vCPU and 128 GB, with the last three restricted to Premium and Ultimate; untagged jobs land on the small runner (Hosted runners on Linux). Windows medium carries a printed factor of 1, but no vCPU or memory figure for it appears in the pages read.

The allowances and the price sit on the commercial side. Free namespaces receive 400 compute minutes a month, Premium 10,000 and Ultimate 50,000, and additional minutes are sold at $10 per 1,000 as a one-time payment available on all plans (Pricing). No page read prices an included minute, so the included allowance and the purchased minute share a name and, on the printed surface, not a rate.

Join the two tables and the ladder stops being proportional. An hour of wall clock on the small runner produces 60 compute minutes spread over 2 vCPU, which is 30 compute minutes per vCPU-hour; medium produces 120 over 4 vCPU, also 30; large 180 over 8, xlarge 360 over 16 and 2xlarge 720 over 32, each 22.5. At the printed add-on price of $0.01 a minute that is $0.30 per vCPU-hour on small and medium and $0.225 on the three larger sizes. The fall is 25 percent and it happens exactly at the 8-vCPU step; the move from 8 to 16 vCPU and from 16 to 32 changes nothing.

This is my division of two printed tables, not GitLab guidance: no page read tells a team how to pick a runner size on cost grounds, and a 2-vCPU machine that finishes the job is usually the cheaper answer than an idle 32-vCPU one.

What lands on the account is a sum, not a duration. The compute-minutes page states that total compute used by a pipeline is the sum of all jobs that ran, so concurrent jobs can make total usage higher than end-to-end pipeline duration. A pipeline whose four jobs each run ten minutes simultaneously on small Linux runners occupies ten minutes of wall clock and records 40 compute minutes, four times the interval a person watching the pipeline would time, and $0.40 of purchased balance at the printed add-on rate. Those are my multiplications from printed values.

The seconds that feed the numerator are recorded in the customer's own job log; the divisor and the multiplier are published by the vendor that scores them.

The purchased balance carries a date. The documentation page for additional minutes says they "Are valid for 12 months from date of purchase if not consumed earlier" and adds that "Expiry of compute minutes is not yet enforced, which allows their use even after the expiry date. However, GitLab does not guarantee that compute minutes will remain valid after the expiry date." (Purchase additional compute minutes). The commercial FAQ is stricter: "Purchased minutes are only valid for 12 months from the date of purchase or until all minutes are consumed, whichever comes first" (Managing compute minutes FAQ). Both are GitLab sentences about the same balance, and neither page settles which one describes month thirteen.

The counter has a perimeter, and it runs along the runner rather than the job. "Group and project runners are not subject to the compute quota" (Compute minutes administration); the quota applies to instance runners, which on GitLab.com are the hosted machines. On GitLab Self-Managed the cost factor is 1 for every project and quotas are off by default, so the factor table is a GitLab.com instrument, and work that runs on hardware the customer pays for directly never enters this meter at all.

Exhaustion is graded rather than abrupt. Instance runners stop picking up new jobs, pending and retried jobs are dropped, and running jobs continue until namespace usage exceeds quota by 1,000 compute minutes, at which point the remaining running jobs are dropped (Compute usage for instance runners). That 1,000-minute band is the only tolerance between a limit and its consequence printed in the pages read, and it is denominated in the scored unit, not in hours.

So the recomputable part is generous. Given a job's seconds, the runner tag it landed on and the plan, the compute-minute quantity follows from published numbers: divide by sixty, multiply by the printed factor, add the jobs together. Convert the overflow at $10 per 1,000 and the marginal price of a busy month is arithmetic. What stays out of reach is the increment that makes two thirds of a minute billable, a dollar value for an included minute, and any printed rule for choosing a runner size. Those are three different missing sentences, and no amount of care with the published ones supplies them.

GitLab has printed the costly half of the instrument with unusual clarity: the divisor, the multiplier, the allowance, the price, the machines behind the runner names, the perimeter and the grace band. The half a buyer needs to reconcile a bill is the increment, and it is not there. A unit that is a name, a division and a score still works as a billing unit. It is not a duration, and a budget that treats it as one will be wrong by whatever the factor says.

GitLab is tracked in the BTW directory: GitLab.