Skip to content

Jenkins in 2026: When It Is Still the Right CI Choice

Jenkins is no longer the default CI, but it still wins for self-hosted, air-gapped and odd-hardware builds. When to keep it, when to leave, and how to run it sanely.

●By 10 min read

For most new projects in 2026, the CI question answers itself: the code lives on GitHub or GitLab, so you use GitHub Actions or GitLab CI and move on. Jenkins shows up in conversations mostly as the thing teams are migrating away from, usually with a story about a plugin upgrade that broke every pipeline on a Friday.

And yet Jenkins still runs a very large share of the world's builds, and for some organisations it remains the better tool, not just the legacy one. This article is about telling those cases apart: where Jenkins genuinely wins, where it is a liability, and, if you keep it, how to run it so it stops being the server everyone is afraid to touch.

What Changed Since Jenkins Was the Default

Jenkins became the default because, for years, it was the only serious open-source option you could run yourself. Three things eroded that position:

CI moved next to the code β€” GitHub Actions and GitLab CI read the pipeline from the repository, show results on the pull request, and need no server to start. For the common case, that removes an entire system from your estate.

Runners became disposable β€” hosted and self-hosted runners start a clean environment per job. Jenkins can do this too, but it is something you build, not the default.

Plugins became the bill β€” Jenkins core does little on its own. A typical controller runs dozens of plugins with their own release cycles, dependencies and security advisories, and someone has to own upgrading them.

Jenkins itself did not stand still. Declarative pipelines, Configuration as Code, the Kubernetes plugin for ephemeral agents, and a regular LTS release line all exist precisely to address the "snowflake server" reputation. The question is whether you need what only Jenkins offers badly enough to adopt those practices.

Where Jenkins Still Wins

SituationWhy Jenkins fitsWhy the alternatives struggle
Air-gapped or classified networksRuns fully offline from a mirrored plugin set; no SaaS dependencyHosted CI is unavailable; self-hosted GitLab works but brings a whole DevOps platform with it
Code spread across many SCMsBitbucket, Gerrit, Perforce, SVN and Git in one placeActions and GitLab CI are built around their own repositories
Unusual build hardwareAny machine with Java and SSH can be an agent: build farms, HSM hosts, test rigs, mainframe gatewaysPossible with self-hosted runners, but less mature for long-lived, stateful hardware
Very long or orchestration-heavy jobsNo hosted job time limits; pipelines can wait for input, lock resources, fan out across agentsHosted runners cap job duration; complex cross-repo orchestration gets awkward
Heavy existing investmentHundreds of working pipelines and shared librariesMigration cost is real and mostly risk with no new features
Strict control over the CI stackYou own every component, version and upgrade windowSaaS CI changes on the vendor's schedule

The common thread is control and heterogeneity. If your builds are standard containerised jobs against one Git host, Jenkins rarely earns its operating cost. If your builds touch physical hardware, legacy version control, or networks that cannot reach the internet, it often still does.

When to Leave

Equally, there are clear signs Jenkins has become pure overhead. If several of these apply, a migration is probably worth the pain:

SignalWhat it usually means
All repositories are on GitHub or GitLabThe native CI already has the integration you are maintaining by hand
Nobody owns the controllerPlugin and security updates are not happening, which is a real risk on an exposed service
Pipelines are freestyle jobs edited in the UINo version history, no review; you would be rewriting them anyway
Builds are all container-basedYou are not using what makes Jenkins distinctive
Upgrades are postponed out of fearThe instance is already a liability; the longer it waits, the harder the jump

Migrate by pipeline, not by big bang β€” move new projects and the simplest pipelines first, keep Jenkins for the hard cases, and switch it off only when nothing is left. Many teams end up with a small Jenkins for the hardware jobs and native CI for everything else, which is a perfectly good outcome.

Inventory first β€” list jobs with their last successful run. A large share of jobs on old controllers have not run in a year and need no migration at all.

sponsored

If You Keep It: Run Jenkins as Code

The healthy way to run Jenkins in 2026 is to treat the controller as disposable: its configuration, plugins and jobs all come from files in Git, so rebuilding it is a deploy, not an archaeology project. Start with an LTS image and a pinned plugin list:

# Dockerfile

FROM jenkins/jenkins:lts-jdk21

COPY plugins.txt /usr/share/jenkins/ref/plugins.txt

RUN jenkins-plugin-cli --plugin-file /usr/share/jenkins/ref/plugins.txt

COPY casc.yaml /var/jenkins_home/casc.yaml

ENV CASC_JENKINS_CONFIG=/var/jenkins_home/casc.yaml

ENV JAVA_OPTS="-Djenkins.install.runSetupWizard=false"

# plugins.txt (pin versions in production)

configuration-as-code

workflow-aggregator

git

kubernetes

credentials-binding

matrix-auth

Configuration as Code (the configuration-as-code plugin, usually called JCasC) replaces the dozens of UI forms under Manage Jenkins with one YAML file. Secrets are referenced from environment variables or a secrets provider rather than written into the file:

# casc.yaml

jenkins:

systemMessage: "Managed by JCasC - changes in the UI will be overwritten"

numExecutors: 0 # the controller runs no builds itself

securityRealm:

local:

allowsSignup: false

users:

- id: "admin"

password: "${JENKINS_ADMIN_PASSWORD}"

authorizationStrategy:

globalMatrix:

permissions:

- "Overall/Administer:admin"

- "Overall/Read:authenticated"

Zero executors on the controller β€” builds run on agents. Running them on the controller lets any pipeline read the controller's files, including credentials, and is the first thing security reviews flag.

Export before you rewrite β€” on an existing instance, the JCasC page under Manage Jenkins can export the current configuration as YAML. Use it as a starting point, then trim what you do not need.

Validate in CI β€” build the image and start it in a throwaway container on every change to plugins.txt or casc.yaml. A plugin conflict found in CI is far cheaper than one found on the live controller.

Pipelines, Agents and Upgrades

Every job should be a Jenkinsfile in its repository, written in declarative syntax, with shared logic in a versioned shared library rather than copied between repos. Running each build in a fresh container on Kubernetes gives you the same clean-environment guarantee that hosted CI runners provide:

// Jenkinsfile

pipeline {

agent {

kubernetes {

yaml '''

apiVersion: v1

kind: Pod

spec:

containers:

- name: build

image: golang:1.23

command: ["sleep"]

args: ["infinity"]

'''

defaultContainer 'build'

}

}

options {

timeout(time: 30, unit: 'MINUTES')

buildDiscarder(logRotator(numToKeepStr: '30'))

}

stages {

stage('Test') { steps { sh 'go test ./...' } }

stage('Build') { steps { sh 'go build -o app ./cmd/app' } }

}

}

The pod template is ordinary Kubernetes YAML, so the same conventions you use elsewhere apply; our Kubernetes generator is handy for resource limits and security context. Agents on physical machines are still fine for hardware-bound work: connect them over SSH or as inbound agents, and keep them single-purpose.

PracticeWhy it matters
Stay on the LTS lineWeekly releases are for testing; LTS gets backported security fixes on a predictable cadence
Upgrade monthly, not yearlySmall plugin jumps rarely break; multi-year jumps often do
Remove unused pluginsEvery plugin is attack surface and an upgrade dependency
Watch the security advisoriesJenkins publishes advisories for core and plugins; check them against your pinned list
Back up JENKINS_HOME anywayBuild history, credentials and job state are not all in Git
Keep it off the public internetPut the UI behind a VPN or SSO proxy; expose only webhook endpoints if needed

Controller on a VM β€” if you run Jenkins as a package rather than a container, it ships as a systemd unit; put overrides such as Java options in a drop-in rather than editing the unit file. Our systemd generator helps with drop-in syntax.

Containers on agents β€” for teams new to building images in CI, our Docker for Linux admins guide covers the daemon and permissions basics that agent setups depend on.

Frequently Asked Questions

Is Jenkins still used in 2026?

Yes, widely. It is no longer the default choice for new projects hosted on GitHub or GitLab, but it still runs a very large number of pipelines, especially in enterprises, regulated and air-gapped environments, and anywhere builds depend on special hardware or several version control systems.

Should I choose Jenkins or GitHub Actions for a new project?

If the code is on GitHub and the builds are standard containerised jobs, GitHub Actions is usually simpler because there is no server to operate. Choose Jenkins when you need fully offline operation, many different SCMs, long-running jobs, or tight control over build hardware and upgrade timing.

What is Jenkins Configuration as Code?

It is a plugin, usually called JCasC, that configures the Jenkins controller from a YAML file instead of the web UI. Combined with a pinned plugin list and Jenkinsfiles in each repository, it lets you rebuild a controller from Git and review configuration changes like any other code.

Why should the Jenkins controller have zero executors?

Builds that run on the controller execute with access to its filesystem, which holds credentials, job configuration and secrets for every project. Running all builds on separate agents, ideally ephemeral containers, keeps a compromised or careless pipeline away from the controller.

How often should I upgrade Jenkins and its plugins?

Follow the LTS release line and upgrade core and plugins on a regular cadence, monthly is a good target, after testing the new image in a throwaway container. Small, frequent upgrades rarely break pipelines, while instances left for years often need a painful multi-step migration.

sponsored

Related Tools

See also