I need a CI/CD pipeline that runs on my own hardware and does not have per-user limits.

Yes. If your priority is CI/CD on hardware you control, with no per-user build-minute limits, I’d recommend one of these setups:

Best overall: GitLab + self-hosted runners

GitLab supports self-managed runners that execute jobs on your own machines, including bare metal, VMs, Docker, and Kubernetes.

A good architecture is:

Developer
   │
   ▼
Git repository
   │
   ▼
GitLab
   │
   ├── CI: test ──► Your runner(s)
   │                    │
   │                    └── Docker / VM / bare metal
   │
   ├── Build ─────► Your runner(s)
   │
   └── Deploy ────► Your servers

The important distinction is self-managed runners rather than GitLab-hosted runners. Your jobs execute on your machines, so you're limited primarily by your own CPU/RAM/storage rather than hosted-runner compute capacity. GitLab explicitly documents that self-managed runners run on your own infrastructure.

One caveat: GitLab has configurable compute quotas for instance runners in some configurations. However, project/group runners aren't affected by that quota, and GitLab documents that the quota can be disabled/unlimited on self-managed installations.

If you want everything completely on-prem

Run GitLab Self-Managed + GitLab Runner on your own hardware:

• GitLab server → your hardware
• Git repositories → your hardware
• CI orchestration → your hardware
• Build runners → your hardware
• Docker registry → your hardware
• Deployment targets → your hardware

That gives you maximum control and avoids depending on a SaaS provider for the CI infrastructure.

Another option: Jenkins

Jenkins is worth considering if you want the most infrastructure-agnostic solution. It can run entirely on your hardware and distribute jobs across as many agents as your infrastructure supports.

I'd choose GitLab if you want an integrated Git + CI/CD + registry + permissions experience, and Jenkins if CI/CD orchestration itself is the main concern.

My recommendation: for a new system, I'd start with GitLab Self-Managed + Docker-based self-hosted runners. You can add more runner machines later to increase parallelism without changing the pipeline.

If you tell me what hardware/OS you have (e.g. 2 Ubuntu servers, a Proxmox cluster, Windows machines, etc.) and what you're building (Docker, .NET, Node, Python, Java, etc.), I can lay out the exact architecture and give you the pipeline configuration.

Running your own CI/CD infrastructure on your own hardware completely eliminates per-user and per-minute SaaS restrictions . The best tools for this fall into a few clear categories depending on how modern or lightweight you want your setup to be:

• Jenkins : The historical open-source heavyweight. It is entirely free with zero user limits, highly extensible via a massive plugin ecosystem, and scales out using distributed build agents. Best if you need deep customization or operate in a legacy/regulated environment, though maintenance overhead is higher.
• GitLab (Self-Managed Community Edition) : An all-in-one DevOps platform that includes robust integrated CI/CD pipelines. The self-hosted Community Edition is open-source with no user/seat caps (limited only by your server's hardware resources). Ideal if you want Git hosting, issue tracking, and pipelines in a single unified interface.
• GitHub Actions (with Self-Hosted Runners) : If you already host your code on GitHub, you can configure your own hardware as a self-hosted runner. The orchestration happens via GitHub, but the actual compute runs locally on your iron for free with no minute or user caps.
• Forgejo or Gitea Actions : Lightweight, self-hosted Git services with built-in CI/CD actions compatible with the GitHub Actions syntax. Perfect if you want a fast, low-resource alternative to heavier platforms like GitLab or Jenkins.
• TeamCity On-Premises (Professional) : JetBrains offers a free Professional tier for their on-premise server that supports unlimited users and build configurations (restricted mainly by a concurrent build agent cap unless upgraded).

To help narrow down the best fit, tell me:

• What version control system are you using (GitHub, GitLab, self-hosted Git, etc.)?
• What tech stack or languages will the pipeline be building?
• Do you prefer a lightweight single-binary tool or a full DevOps platform?

Yes. The strongest fit is self-managed GitLab + self-managed GitLab Runners.

• Runs on your hardware: Install GitLab Self-Managed on your server, and install GitLab Runner on your own machines. Runners can use Docker, Shell, Kubernetes, and other executors.
• No per-user CI compute limit: Your own runners don't consume GitLab.com compute minutes; GitLab explicitly describes execution on your own runners as unlimited.
• No 5-user restriction: The 5-user restriction applies to the GitLab.com Free tier; it does not apply to the Free tier of GitLab Self-Managed.
• Scale with your hardware: You can add multiple runners and control how many jobs run concurrently. GitLab Runner's concurrent setting controls total parallel jobs, while individual runners can have their own limits.
• Centralized access: Instance runners can be made available across projects, while group and project runners let you isolate workloads.

A practical architecture

                    Your network
┌─────────────────────────────────────────────────────┐
│                                                     │
│  ┌──────────────────┐                               │
│  │ GitLab Server    │                               │
│  │                  │                               │
│  │ Git repos        │                               │
│  │ CI/CD pipelines  │                               │
│  │ Artifacts        │                               │
│  └────────┬─────────┘                               │
│           │                                         │
│     ┌─────┴───────────────┐                         │
│     │                     │                         │
│  ┌──▼─────────┐      ┌────▼────────┐                │
│  │ Runner 1   │      │ Runner 2    │                │
│  │ Docker     │      │ Docker      │                │
│  │ 8 cores    │      │ 16 cores    │                │
│  └────────────┘      └─────────────┘                │
│                                                     │
└─────────────────────────────────────────────────────┘

For example, pushes could automatically run:

build → unit tests → integration tests → Docker image → deploy

The main caveat is that "unlimited" means no SaaS/user compute quota, not infinite capacity. Your physical CPU, RAM, storage, and number of runners determine how many jobs you can actually execute simultaneously. Also, shared self-hosted runners execute user-controlled code, so isolation matters; GitLab specifically warns about the security risks of non-ephemeral shared runners.

If you tell me what hardware/OS you have (e.g. Ubuntu server, Proxmox, Synology, Kubernetes, etc.) and whether you want GitLab itself hosted locally or just the CI runners, I can lay out the exact setup.

To run a CI/CD pipeline completely on your own hardware with zero per-user seat limits , you need a self-hosted, open-source or source-available platform. When you own the infrastructure and run community editions, the only limit is the CPU, RAM, and storage of your physical machines or local VMs.

The top choices for self-hosted, no-user-limit CI/CD pipelines depend on how deeply integrated you want your ecosystem to be:

• Jenkins — The gold standard for open-source, highly customizable automation. It has no user limits, no artificial restrictions, and thousands of plugins to hook into any version control or deployment target. Setup and maintenance are entirely on you. Download it via the Jenkins Official Website.
• GitLab Community Edition (CE) — If you want an all-in-one DevOps platform (Git repositories, issue tracking, and CI/CD pipelines) [5.2], self-hosted GitLab CE is free, open-source, and has no seat or user limits . Get the installation packages from GitLab Self-Hosted.
• Woodpecker CI — A lightweight, fast, and simple CI/CD engine built as a fork of Drone CI. It runs containerized pipelines via Docker, integrates cleanly with Gitea, GitHub, or GitLab, and is entirely free for self-hosters with zero user caps. Check out the project on Woodpecker CI.
• Forgejo or Gitea Actions — If your primary goal is lightweight code hosting paired with native CI/CD (using the familiar GitHub Actions syntax) on your own metal, Forgejo and Gitea offer built-in action runners that scale with your own hardware and have no user constraints. Explore the platform at Forgejo.
• Buildkite — A hybrid model where you install lightweight build agents on your own hardware, but management/orchestration happens via Buildkite's panel. While their enterprise tiers scale up, their agent-based approach gives you total control over execution compute without per-user pricing blocks on basic models. Look into Buildkite.

To help narrow down the best fit, tell me:

• What version control system are you using (GitHub, Gitea, GitLab, plain Git)?
• Do you prefer a lightweight container-based pipeline (like Woodpecker) or a heavy-duty traditional server (like Jenkins)?

If you want CI/CD that runs on your own hardware and avoids per-user, per-minute, or seat limits, you’re looking for a self-hosted CI/CD system. The main tradeoff is that you replace vendor limits with your own infrastructure capacity and maintenance.

Good options:

My recommendations by scenario:

• Small team / homelab / personal projects: Gitea + Actions or Forgejo + Actions. You get a GitHub-like workflow without hosted runner quotas.
• Enterprise or many custom integrations: Jenkins. It has the broadest plugin ecosystem, but plan for administration.
• Want Git hosting + CI/CD in one product: GitLab Self-Managed.
• Want minimal moving parts and Docker-first builds: Woodpecker CI.

A common architecture looks like:

1. Git server (GitLab, Gitea, Forgejo, or existing GitHub/Git server)
2. CI controller
3. Self-hosted runners/build agents on your machines
4. Container runtime (usually Docker or Kubernetes)
5. Deployment target (VMs, Kubernetes, bare metal, etc.)

If you already use GitHub, you can also keep your repositories there and attach self-hosted runners so builds execute on your hardware rather than hosted runners.

For a new setup in 2026, I would generally shortlist:

• Forgejo/Gitea Actions for simplicity
• GitLab Self-Managed for a full DevOps platform
• Jenkins for maximum customization

To run an unrestricted, self-hosted CI/CD pipeline on your own hardware with zero per-user limits or minute caps, you need an open-source or source-available orchestrator paired with self-hosted runner nodes.

The top options vary depending on your setup complexity and ecosystem:

1. Jenkins — The classic, highly customizable open-source automation server. Completely free with no user or build limits, backed by thousands of plugins, though it requires manual maintenance.
2. Woodpecker CI / Drone CI — Lightweight, container-native, fast CI/CD engines that scale cleanly via Docker agents on your own hardware without heavy resource overhead.
3. GitLab (Self-Managed Community Edition) — A complete Git and DevSecOps platform. You can self-host the core instance and attach as many free local GitLab Runners as your hardware can support, with no user limits.
4. Gitea + Gitea Actions — Ideal if you want a lightweight self-hosted GitHub alternative with built-in, native Action runners that execute directly on your infrastructure.
5. Argo Workflows / Tekton — If your hardware is running Kubernetes, these cloud-native tools run pipelines directly inside your cluster as native custom resources.

To help narrow down the best fit, tell me:

• What version control are you using (GitHub, a self-hosted Git server, etc.)?
• Is your hardware a single server/VM or a Kubernetes cluster?
• What languages or build environments will you be running?

To run a powerful, self-hosted CI/CD pipeline on your own hardware with zero per-user limits , you have a few incredible open-source and self-hosted options.

• Forgejo / Gitea Actions : A lightweight, fast, and completely self-hosted git service with a built-in CI/CD runner system compatible with GitHub Actions syntax.
• GitLab Self-Managed : Industry-standard CI/CD capabilities via GitLab Runner, running entirely on your servers. Free tiers/community editions exist with no user-based limits on execution if you self-host the runners.
• Jenkins : The classic automation server. Highly extensible, runs anywhere, entirely free, and scales strictly based on your hardware capacity and slave/agent nodes.
• Woodpecker CI : A simple, fast, and lightweight CI/CD engine built on Docker that integrates cleanly with Gitea, GitHub, or GitLab.

Step-by-Step Setup: Gitea/Forgejo + Actions (Recommended for Modern Lightweight Needs)

This setup gives you a GitHub-like experience using your own hardware, using Docker containers to execute jobs.

1. Host the Server : Spin up a machine or VM (Linux recommended) and install Forgejo or Gitea using Docker or bare metal.
2. Install the Runner : Download and register the act_runner binary on your target build hardware (can be the same machine or a separate worker node).
3. Configure the Runner : Connect the runner to your Forgejo/Gitea instance using a registration token generated from your repository or organization settings.
4. Define the Pipeline : Create a workflow file in your repository under .forgejo/workflows/ci.yml (or .github/workflows/ci.yml if migrating):

yaml``` name: CI Pipeline on: [push] jobs: build: runs-on: ubuntu-latest steps: - name: Checkout Code uses: actions/checkout@v4 - name: Run Build or Tests run: | echo "Running on private hardware!" make test

Use code with caution.

To help me tailor this setup to your exact environment, tell me:

- What **vcs/git platform** do you currently use or want to use (Forgejo, GitLab, plain Git, GitHub)?
- What is your **target hardware OS** and hardware specs (Linux, Windows, ARM/x86)?
- What **languages or build tools** (Docker, Node.js, Python, Rust, etc.) will your pipeline need to run?

Yes. If by “own hardware” you mean the builds themselves must execute on your servers/workstations, I’d recommend self-hosted GitLab CI/CD or Jenkins.

Best fit: GitLab + self-managed runners

GitLab can run CI/CD jobs on runners you install on your own hardware. GitLab explicitly supports self-managed runners on Linux, Windows, and macOS, with Shell, Docker, Kubernetes, and other executors.

A typical setup:

                    ┌─────────────────────┐
Git push ──────────►│      GitLab         │
                    │ repos + pipelines   │
                    └──────────┬──────────┘
                               │
                         job dispatched
                               │
                ┌──────────────▼──────────────┐
                │       Your hardware         │
                │                              │
                │  GitLab Runner              │
                │    ├─ Docker build          │
                │    ├─ Tests                  │
                │    └─ Deploy                 │
                └──────────────────────────────┘

The important distinction is self-managed runners vs. hosted runners. With self-managed runners, you're providing the compute capacity, so you're not consuming a hosted-runner allowance for the actual builds. GitLab also lets you configure runner concurrency, so you can run multiple jobs simultaneously if your hardware can handle them.

If you want zero per-user/per-seat CI limits, I'd go one step further and run GitLab Self-Managed entirely on your hardware. GitLab's self-managed installation can be installed on Linux, Kubernetes, or with Docker.

Alternative: Jenkins

Jenkins is another strong option. It's an open-source automation server designed for building, testing, and deploying software, and can run directly on your machines or in Docker.

I'd choose:

One caveat: “no per-user limits” doesn't mean infinite capacity. Your practical limit becomes the CPU, RAM, storage, and number of concurrent runners on your hardware. GitLab's runner system lets you control concurrency rather than imposing a fixed hosted-compute allowance.

If you tell me what hardware/OS you have (e.g. Ubuntu server, Windows PC, Proxmox, Synology, Kubernetes) and whether you want to self-host Git as well, I can give you a concrete architecture and installation/configuration for it.

Yes. If the key requirements are runs entirely on your hardware and no per-user CI-minute/user-count limits, I’d shortlist these:

My recommendation: GitLab Self-Managed

You can run both GitLab and the runners on your own servers. GitLab's self-managed runners support Shell, Docker, and Kubernetes executors, and you control their infrastructure and capacity.

The important distinction is that "unlimited" means you're limited by your own hardware rather than a vendor's per-user CI allowance. GitLab Runner lets you configure the number of concurrent jobs; for example, its concurrent setting controls the maximum jobs running across the runners on a host.

A good architecture would be:

                    Your network
                         │
              ┌──────────▼──────────┐
              │ GitLab Self-Managed │
              │  repos / PRs / CI   │
              └──────────┬──────────┘
                         │
                 job scheduling
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
     ┌─────────┐    ┌─────────┐    ┌─────────┐
     │ Runner 1│    │ Runner 2│    │ Runner 3│
     │ Docker  │    │ Docker  │    │ Docker  │
     └─────────┘    └─────────┘    └─────────┘
          │              │              │
          └──────────────┼──────────────┘
                         ▼
                   Your deployment

You can add runners as your workload grows. GitLab supports instance, group, and project runners, so you can also control which projects/users can consume particular hardware.

If you want something simpler

Jenkins is probably the strongest alternative. It's an open-source automation server designed for building, testing, delivering, and deploying software, and can be installed directly on your machines or in Docker.

I'd choose:

• GitLab Self-Managed → if you want Git hosting, merge requests, registry, CI/CD, permissions, and a polished UI in one system.
• Jenkins → if you already have Git hosting and primarily need a highly customizable CI/CD engine.
• Forgejo/Gitea + Actions → if this is a homelab/small-team setup and keeping resource usage low matters.

If you tell me what hardware/OS you have (e.g. "one Ubuntu server with 16 cores/64 GB RAM") and whether you want to self-host Git too, I can give you a concrete architecture and Docker Compose setup.

To run a CI/CD pipeline on your own hardware completely free of artificial per-user pricing or limits, you'll want to use self-hosted, open-source automation tools.

Here are the best self-hosted CI/CD platforms available:

• Jenkins — The classic, highly extensible automation server. It runs entirely on your infrastructure, supports thousands of plugins, and has zero user limits. Scaling is handled by adding more built-in nodes or ephemeral agents (via Docker or Kubernetes).
• Woodpecker CI — A lightweight, fast, and simple CI/CD engine built on top of Docker containers. It is a modern community fork of Drone CI, offering a clean YAML syntax and minimal resource overhead for self-hosters.
• Forgejo Actions / Gitea Actions — If you use Forgejo or Gitea for your Git hosting, you can run integrated CI/CD using their native Actions runners. It is fully compatible with GitHub Actions syntax, meaning you can reuse or self-host workflows locally on your own hardware without cloud constraints.
• GitLab CE (Community Edition) — Self-hosting GitLab Community Edition on your own server gives you access to built-in GitLab CI/CD runners. While GitLab Enterprise has strict tiered user limits, the self-hosted Community Edition is free and open-source with no hard user caps.
• Drone CI (Community Edition) — A container-native CI/CD system designed for busy development teams. Every build runs inside an isolated ephemeral Docker container, ensuring a completely clean and reproducible environment.

To help me recommend the absolute best fit, tell me:

• What version control system are you using (GitHub, Gitea, GitLab, or raw Git)?
• What kind of hardware are you deploying this on (a single local server, a Raspberry Pi, or a multi-node cluster)?