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
| Situation | Why Jenkins fits | Why the alternatives struggle |
|---|---|---|
| Air-gapped or classified networks | Runs fully offline from a mirrored plugin set; no SaaS dependency | Hosted CI is unavailable; self-hosted GitLab works but brings a whole DevOps platform with it |
| Code spread across many SCMs | Bitbucket, Gerrit, Perforce, SVN and Git in one place | Actions and GitLab CI are built around their own repositories |
| Unusual build hardware | Any machine with Java and SSH can be an agent: build farms, HSM hosts, test rigs, mainframe gateways | Possible with self-hosted runners, but less mature for long-lived, stateful hardware |
| Very long or orchestration-heavy jobs | No hosted job time limits; pipelines can wait for input, lock resources, fan out across agents | Hosted runners cap job duration; complex cross-repo orchestration gets awkward |
| Heavy existing investment | Hundreds of working pipelines and shared libraries | Migration cost is real and mostly risk with no new features |
| Strict control over the CI stack | You own every component, version and upgrade window | SaaS 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:
| Signal | What it usually means |
|---|---|
| All repositories are on GitHub or GitLab | The native CI already has the integration you are maintaining by hand |
| Nobody owns the controller | Plugin and security updates are not happening, which is a real risk on an exposed service |
| Pipelines are freestyle jobs edited in the UI | No version history, no review; you would be rewriting them anyway |
| Builds are all container-based | You are not using what makes Jenkins distinctive |
| Upgrades are postponed out of fear | The 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.
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.
| Practice | Why it matters |
|---|---|
| Stay on the LTS line | Weekly releases are for testing; LTS gets backported security fixes on a predictable cadence |
| Upgrade monthly, not yearly | Small plugin jumps rarely break; multi-year jumps often do |
| Remove unused plugins | Every plugin is attack surface and an upgrade dependency |
| Watch the security advisories | Jenkins publishes advisories for core and plugins; check them against your pinned list |
| Back up JENKINS_HOME anyway | Build history, credentials and job state are not all in Git |
| Keep it off the public internet | Put 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.