contenox

Source code platform pricing: what the seat price leaves out

Updated

WORKING WITH AGENTSSource code platform pricing

Source code platform pricing is quoted per seat, and the seat is the least useful number on the page. Ten developers on GitHub Team pay $40 a month for seats; the same ten with GitHub’s two security products and Copilot Business pay $732. GitLab charges $29 a seat and includes 10,000 CI minutes. AWS charges $1 a seat after the first five and includes no CI at all.

Each platform puts the money somewhere else: in CI minutes, in security billed per committer, in AI credits, or, for self-hosted and cloud-provider git, in work nobody invoices.

What each platform charges

List prices in US dollars per month, read on each platform’s official page on 12 November 2026.

Platform Per user CI included More CI
GitHub Team $4, Enterprise $21; Free has no user cap $12 (Free), $18 (Team) or $300 (Enterprise) of compute; $18 buys 3,000 Linux minutes $0.006 a Linux minute
GitLab.com Premium $29, billed annually; Ultimate on request 400 (Free), 10,000 (Premium) or 50,000 (Ultimate) minutes $10 per 1,000 minutes
Bitbucket Cloud Standard $3.65, Premium $8 50 (Free), 2,500 (Standard) or 3,500 (Premium) minutes $10 per 1,000 minutes, not on Free
Azure DevOps $6 after 5 free users One job, 1,800 minutes, with an Azure subscription linked $40 per hosted job, $15 per self-hosted job, unlimited minutes
AWS CodeCommit $1 after 5 free active users None; CodeBuild adds 100 minutes $0.005 a CodeBuild minute
Google Secure Source Manager $1,000 per instance, any number of users None; builds run in Cloud Build Cloud Build prices
Gitea Enterprise, self-hosted $9.50, one-year commitment; Gitea itself is free Own runners Own hardware
SourceHut $4, $8 or $12 per account; € in Europe, VAT extra builds.sr.ht with a paid account Within the plan
Codeberg Free, donation-funded, open source only Woodpecker CI on request None to buy

What does a team of ten actually pay?

Ten developers, private repositories, 5,000 minutes a month on the smallest Linux runner, at the list prices above:

Setup Per month How it adds up
GitHub Team $52 10 seats × $4, plus $12 for the 2,000 minutes beyond the included $18
GitHub Team with Secret Protection, Code Security and Copilot Business $732 $52, plus 10 committers × ($19 + $30), plus 10 Copilot seats × $19
GitLab Premium $290 10 seats × $29; the 5,000 minutes fit into the 10,000 included
Bitbucket Standard $66.50 10 seats × $3.65, plus three blocks of 1,000 minutes beyond the 2,500 included
Azure DevOps Basic $70 5 free users, 5 × $6, plus one Microsoft-hosted parallel job at $40
AWS CodeCommit with CodeBuild $30.50 6 paid active users × $1, plus 4,900 build minutes × $0.005
Google Secure Source Manager $1,000 plus builds One instance, any number of users

The AWS line counts eleven active users, not ten: AWS counts identities that other AWS services such as CodeBuild create as active users, so the build pipeline takes a seat.

Read across the rows, the seat price explains almost nothing. On GitHub the seats are $40 of $732, about 5%. GitLab’s expensive seat includes the CI that GitHub sells by the minute, plus $12 of AI credits per user that GitLab calls “a promotional offer available for a limited time”. Azure DevOps sells the same two security products as GitHub at the same prices, $19 and $30 per committer. On seat price alone, Google’s flat $1,000 only undercuts GitLab Premium at about 35 users, and GitHub Team at 250.

AWS is the cheapest row and the one with the most missing. CodeCommit stores the code; the build, the trigger and the registry are separate services wired together by hand, shown further down.

Why does a GitHub bill grow past the seat price?

Three mechanisms put the cost into lines the seat price doesn’t show.

The included CI is money, not minutes. GitHub’s docs say the allowance “is expressed as a monetary amount, not a fixed number of minutes”. At $0.006 a minute, Team’s $18 is 3,000 minutes on the standard Linux runner; a macOS minute costs $0.062, so the same $18 runs about 290 of them. Hosted runner prices dropped by up to 39% on 1 January 2026, which made the same dollars go further.

AI review now draws on the same budget. Since 1 June 2026, every Copilot code review on a private repository consumes Actions minutes from the included allowance, and anything beyond it is billed at standard Actions rates. A team that turns on automatic review for every pull request spends part of its build allowance on it. Public repositories are not affected.

Self-hosted runners are free, but GitHub has already announced otherwise once. On 16 December 2025 it announced a “$0.002 per minute GitHub Actions cloud platform charge” for self-hosted runners from 1 March 2026, then postponed it to re-evaluate the approach, with no new date. Moving builds onto company hardware saves the hosted rate today. It is not a guaranteed exit from Actions billing.

Which source code platforms are free?

Five is the common free limit: GitLab allows 5 users per top-level group with private projects, Bitbucket and Azure DevOps 5 users, AWS CodeCommit 5 active users, who share 50 GB and 10,000 git requests a month. SourceHut requires a paid account for builds but leaves paying for git hosting optional during its alpha. GitHub Free has no user cap and unlimited private repositories, with $12 of CI a month for them; standard hosted runners in public repositories cost nothing.

Codeberg is free in every sense but not a free private GitHub. Its terms say “Private repositories are only allowed for things required for FLOSS projects”, and its FAQ caps private content at 100 MB. It suits open-source work, not a company’s closed code.

GitHub Codespaces is billed apart from all of this: a 2-core machine costs $0.18 an hour, plus $0.07 per GB-month of storage.

What does a private GitHub repository pay for that a public one gets free?

On GitHub, visibility works like a price tier. In a public repository, standard hosted runners cost nothing, and code scanning, secret scanning alerts, push protection and dependency review are free. In a private repository, the same minutes draw on the paid allowance, and the same scanning is sold as Secret Protection at $19 and Code Security at $30 per active committer: $490 of the $732 in the team-of-ten bill above. Release controls follow the same line. On Free, Pro and Team, required reviewers on a deployment environment “are only available for public repositories”, and artifact attestations, signed records of where and how a build output was made, need Enterprise Cloud in a private repository.

The release setup of the open source project behind this site sits on exactly that line. Development happens in a private monorepo, and the public repository moves only by release: each commit on it is one release’s complete tree, each tag is signed and carries the release notes, and CI builds the binaries from the tag, writes checksums and attests provenance. The write-up of that setup, AI Killed Git Commits, asks GitHub for a “release drop” repository mode and lists pieces the platform already has: immutable releases, build attestations, environments with required reviewers. Below Enterprise, attestations and required reviewers both work only in public repositories.

The write-up gives a different reason for the split: on a tree that agents write, the intermediate commits “stopped carrying information worth publishing”. Nor does the split make CI free. “There is no public CI”: the tests run before the drop, on the private side, and cost whatever CI costs there. What that history looked like is in Git workflow with AI agents.

Is self-hosting GitLab or Forgejo free?

The licence is. GitLab’s Community Edition and the Free features of its Enterprise Edition cost nothing, Gitea is MIT-licensed, and Forgejo is GPL v3 or later since version 9. What remains is a machine, upgrades, backups and somewhere for CI to run, and each project’s docs set the size of each.

What does GitLab need?

GitLab’s requirements page sets a single-node baseline of 8 vCPU and 16 GB of memory, says “GitLab can run with at least 8 GB of memory” in constrained environments, and advises to “Disable swap where possible”. A separate guide for memory-constrained environments describes a much smaller install: “Minimum 2 GB of RAM + 1 GB of SWAP”, one CPU core, for “up to 5 developers with individual Git repositories no larger than 100 MB”. The small install exists, but on terms the main requirements page advises against.

The Linux package bundles PostgreSQL, Redis and Sidekiq, so one package installs and upgrades everything. Upgrades are the cost that never shows at install time. GitLab has required upgrade stops at x.2, x.5, x.8 and x.11 since 17.5, and each stop’s background migrations must finish before the next. A server left a year behind climbs through every stop in between.

The backup trap: sudo gitlab-backup create writes one archive with the database, repositories, LFS objects and uploads, and leaves the configuration files out. /etc/gitlab/gitlab-secrets.json and /etc/gitlab/gitlab.rb need their own copy, kept apart on purpose: “Storing encrypted information in the same location as its key defeats the purpose”.

What about GitLab on Kubernetes?

The official Helm chart installs with two commands:

helm repo add gitlab https://charts.gitlab.io/
helm upgrade --install gitlab gitlab/gitlab \
  --timeout 600s \
  --set global.hosts.domain=example.com \
  --set global.hosts.externalIP=10.10.10.10 \
  --set certmanager-issuer.email=me@example.com

The commands are short; the cluster isn’t. The chart docs ask for “at least 8 vCPU and 30 GB of RAM”, with an example configuration for a 3 vCPU, 12 GB cluster meant for non-production use. And Kubernetes doesn’t make GitLab self-contained; it moves the stateful parts out: “External PostgreSQL, Redis, and object storage are required.” Gitaly, the service that stores the repositories, has run in Kubernetes as generally available since GitLab 18.11, and the docs call it “a single point of failure service”: rotating its pod interrupts service. The chart also has its own version numbers, so chart 10.5.6 installs GitLab 19.5.5, and the upgrade stops above still apply.

A capacity check of a small home cluster, recorded on 15 October 2026, shows what that floor means on modest hardware. Three k3s nodes ran as VMs on one machine with four cores and about 15 GiB of RAM. The two workers offered 5.80 GiB of allocatable memory together, with 1.2 to 1.3 GiB free on each, and “a single pod cannot combine the two nodes’ memory”. The cluster’s Longhorn storage placed both of its replica disks on the same host and the same physical data disk, so a second replica could not have survived a disk failure. The same record noted that GitLab’s constrained minimum of 8 GB did not fit the worker allocation; the chart’s 30 GB is five times the cluster’s entire allocatable memory. The cluster was deleted on 26 October 2026.

What does a small Forgejo setup look like?

The same home lab went through four forge setups before one stuck: Gogs on a VM and Gogs on the k3s cluster, both gone, then Forgejo on the cluster, to arrive at, Forgejo on a plain VM. The last one is small enough to show whole.

The VM has 2 cores, 4 GB of RAM and a 250 GB disk, runs Ubuntu 22.04, and holds nine repositories. Forgejo 17.0.1 and PostgreSQL 18.6 run in Docker Compose with both images pinned by tag and digest, installed by an Ansible role. Trimmed to what matters:

name: forgejo
services:
  forgejo:
    image: codeberg.org/forgejo/forgejo:17.0.1@sha256:fcd19ff4ebc85fb098a67e8e1d0d5a84d07dd6e8a23edcfdfd5b71a6178953be
    depends_on:
      - db
    env_file:
      - /etc/forgejo/forgejo.env
      - /etc/forgejo/mail.env
    environment:
      FORGEJO__database__DB_TYPE: postgres
      FORGEJO__database__HOST: "db:5432"
      FORGEJO__server__ROOT_URL: "https://git.example.com/"
      FORGEJO__server__SSH_PORT: "22"
      FORGEJO__server__LFS_START_SERVER: "true"
      FORGEJO__service__DISABLE_REGISTRATION: "true"
      FORGEJO__service__REQUIRE_SIGNIN_VIEW: "true"
      FORGEJO__repository__DEFAULT_PRIVATE: private
      FORGEJO__actions__ENABLED: "true"
    ports:
      - "3000:3000"
      - "2222:22"
    restart: unless-stopped
    volumes:
      - /var/lib/forgejo/data:/data

  db:
    image: docker.io/library/postgres:18.6@sha256:edb0c08dc33befd0262ab3b5cf1c4f3f8cfd8b09e88c05b45adee29d6761ddb6
    env_file:
      - /etc/forgejo/db.env
    environment:
      POSTGRES_DB: forgejo
      POSTGRES_USER: forgejo
    restart: unless-stopped
    volumes:
      - /var/lib/forgejo/postgres:/var/lib/postgresql

The database password, secret key, internal token and JWT secret are generated on the server on first run and live only in root-owned env files there. Registration is off, every page needs a sign-in, and new repositories are private.

Forgejo was the easy part. The home connection takes no public web or git traffic directly; HTTPS and git over SSH both enter through a rented VPS. The SSH path:

Internet :22 → VPS (HAProxy, TCP) → WireGuard tunnel → home gateway → VM :2222 (Forgejo's SSH)

Self-hosted still meant renting a server. Through that path, a 205 MB push with 683 tags took 87 seconds.

Backups run nightly at 03:30 from a systemd timer and keep seven days:

stamp=$(date +%Y%m%d-%H%M%S)
compose="docker compose -f /opt/forgejo/compose.yml"
$compose exec -T -u git forgejo forgejo dump --config /data/gitea/conf/app.ini \
  --tempdir /tmp --type tar.gz --skip-log --skip-index --skip-repo-archives \
  --file - > "/var/backups/forgejo/forgejo-dump-$stamp.tar.gz"
$compose exec -T db pg_dump -U forgejo -Fc forgejo > "/var/backups/forgejo/forgejo-db-$stamp.dump"

The test run produced a 432 MB dump with all nine repositories and a 2 MB database dump whose pg_restore --list showed 131 tables. Two gaps remain. The backups stay on the same VM, so one dead disk takes the forge and every copy of it. And Forgejo’s backup guide recommends no specific tool and calls it “strongly recommended to shut down Forgejo during a backup”, which this setup doesn’t do: it trades a consistent snapshot for a forge that never goes offline at night.

Upgrades come on a schedule here too. Forgejo ships a stable release every quarter and supports it for “three months, plus a two week window”; 17.0.1 reaches end of life on 28 January 2027. The yearly LTS release, currently 15.0.11, is supported until 15 July 2027. With images pinned by digest, every upgrade is a deliberate edit, and on the stable line that edit is due every quarter.

Where does CI run on a self-hosted forge?

FORGEJO__actions__ENABLED is on in that file, and no job has ever run, because no runner is registered. “Forgejo does not run the jobs, it relies on the Forgejo Runner”, which is installed and configured separately.

The runner is the part the docs warn about. Forgejo’s security page says runners’ “entire purpose is to perform remote code execution”, that the host label runs jobs “in the same host without any isolation”, and that a runner registered site-wide “can run a job in any repository”. GitLab’s runner docs say privileged mode means “effectively disabling all the container’s security mechanisms” and put privileged runners “only on isolated and ephemeral virtual machines”.

So a safe runner needs machines of its own, ideally a fresh one per job. That is exactly what the hosted platforms price per minute. A self-hosted forge doesn’t make CI free; it makes isolating CI the team’s job.

Is AWS CodeCommit still available?

Yes. AWS closed CodeCommit to new customers on 25 July 2024 and reversed that on 24 November 2025: “CodeCommit is returning to full General Availability, effective immediately”, with new sign-ups open, pricing unchanged and 29 regions. The pricing page still carried the 2024 banner, “AWS CodeCommit is no longer available to new customers”, on 12 November 2026; the AWS blog post and the user guide’s history are the current word. Git LFS is on the roadmap, so large binaries have no place in it yet.

Access works three ways: an SSH key attached to an IAM user, static HTTPS git credentials generated in IAM, or git-remote-codecommit for federated and temporary credentials. For SSH, the IAM console shows an SSH key ID after the public key is uploaded, and that ID goes into ~/.ssh/config as the user:

Host git-codecommit.*.amazonaws.com
  User APKAEIBAERJR2EXAMPLE
  IdentityFile ~/.ssh/codecommit_rsa

What does a CodeCommit setup look like?

One web app’s release pipeline, in Terraform. The repository, and a push-only IAM user whose policy reaches that one repository and nothing else:

variable "git_ssh_public_key" {
  type = string
}

resource "aws_codecommit_repository" "app" {
  repository_name = "app"
  default_branch  = "main"

  lifecycle {
    prevent_destroy = true
  }
}

resource "aws_iam_user" "git" {
  name = "git"
}

resource "aws_iam_user_ssh_key" "git" {
  username   = aws_iam_user.git.name
  encoding   = "SSH"
  public_key = var.git_ssh_public_key
}

resource "aws_iam_user_policy" "git" {
  name = "app-push"
  user = aws_iam_user.git.name

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect   = "Allow"
      Action   = ["codecommit:GitPull", "codecommit:GitPush"]
      Resource = aws_codecommit_repository.app.arn
    }]
  })
}

A release starts when a tag beginning with v is pushed. On GitHub that is on: push: tags: ['v*'] in a workflow file. On AWS it is an EventBridge rule:

resource "aws_cloudwatch_event_rule" "release_tag" {
  name = "app-release-tag"

  event_pattern = jsonencode({
    source        = ["aws.codecommit"]
    "detail-type" = ["CodeCommit Repository State Change"]
    resources     = [aws_codecommit_repository.app.arn]
    detail = {
      event         = ["referenceCreated"]
      referenceType = ["tag"]
      referenceName = [{ prefix = "v" }]
    }
  })
}

Behind that rule sit eight more resources: the rule’s target, an IAM role and policy that let EventBridge start the build, the CodeBuild project with its own role and policy, and an ECR repository with a policy for the image. The build’s first command checks that it is building the tag it was started for, test "$CODEBUILD_SOURCE_VERSION" = "refs/tags/$TAG". Every part is cheap, and every part is the team’s to maintain.

That repository is also a mirror. The team’s origin fetches from a self-hosted forge and pushes to both:

git remote set-url --add --push origin https://git.example.com/team/app.git
git remote set-url --add --push origin ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/app

Both lines are needed. Once a remote has push URLs, “Pushing to a remote affects all defined pushurls”, so the forge’s own URL has to be added back as one of them or pushes stop reaching it.

What about Google Cloud and Azure?

Google Secure Source Manager is “a regionally deployed, single-tenant managed source code repository”. Each instance costs $1,000 a month “regardless of users per instance”, in 11 regions including europe-west2, europe-west4, me-west1 and me-central2. Builds run through Cloud Build triggers or webhooks. The pricing page also mentions licensed-user pricing with “details below” that the page doesn’t contain.

Azure Repos comes with every Azure DevOps Basic user: unlimited private Git repositories, the first five users free. Public projects are being retired: announced in April 2026, and in 2027 the remaining public projects convert to private, with their unlimited free pipeline minutes cut to 1,800.

Forgejo or Gitea?

Forgejo started as a soft fork of Gitea and became a hard fork in early 2024, saying that being a drop-in replacement “will no longer be guaranteed”. Moving from Gitea still works from the last version before the split, v1.21.5. The licences diverged in August 2024: Forgejo releases from v9.0 are GPL v3 or later, while Gitea stays MIT. The company behind Gitea sells Gitea Enterprise at $9.50 per user a month with a one-year commitment, and a hosted Gitea Cloud whose prices sit behind a sign-in.

For a team that only needs to run the forge, either works. For a company that plans to modify and redistribute it, the licence is the difference.

Related

Esc to close