The original CI / CD workhorse. Still installed in tens of thousands of enterprises —
and still the fastest way to get hired into one.
TopologyOne controller · many ephemeral agents
Set the scene
A large bank has a team of 30 engineers. They’ve been writing Java since 2008.
They have 700 microservices, an on-prem Kubernetes cluster, a regulator that audits
everything, and a CI server — Jenkins — that has been
running for ten years.
Someone suggests replacing Jenkins with the latest cloud-native CI tool. The team
leader asks two questions: "Will the regulator accept the audit trail?"
and "How long to migrate 700 pipelines?". The answers are "unclear"
and "two years". Jenkins stays.
This is why Jenkins still matters in 2026. It is not the most fashionable tool. It is
the most installed one. If you can read and write a Jenkinsfile, you can earn
a senior salary at any of those banks — for the next ten years.
01What is Jenkins?
Jenkins is an open-source automation server. You give it a job (build, test, deploy
— or anything you can run on a command line) and it runs that job for you,
repeatably, on a schedule, on push, or on a button click.
The simple version
Jenkins is a server that runs scripts on a server, on demand, with a friendly web UI
and a button labelled "Build Now".
The technical version
Jenkins is a Java application that schedules and executes "pipelines" (declarative or
scripted Groovy programs) on "agents" (workers). A controller stores configuration
and coordinates work; agents do the actual building.
The historical version
Born in 2004 as Hudson, renamed in 2011, Jenkins is the oldest open-source CI server
still in widespread use. It defined the category — every modern CI tool borrows
from its vocabulary.
02Why Jenkins is still installed everywhere
New CI tools come and go. Jenkins keeps surviving for four very specific reasons.
Reason 01
It runs on your hardware
Self-hosted by default. Air-gapped data centres, regulated industries, customers who
can’t send their code to a SaaS — Jenkins is the answer. No vendor needs
to approve your move.
Reason 02
A plugin for everything
Two thousand plus plugins. Whatever obscure VCS, build tool, deploy target or
notification channel your enterprise uses, there is a Jenkins plugin for it. The plugin
ecosystem is the moat.
Reason 03
It speaks the regulator’s language
Built-in audit logs, role-based access, signed artifacts, mature credential management,
integrations with on-prem secret stores. Compliance teams know it and trust it.
Reason 04
Pipelines as code
Since 2016, you can describe a whole pipeline in a single Jenkinsfile in
your repo. Modern Jenkins looks nothing like the click-driven monster of a decade ago.
03Five words to read any Jenkinsfile
These are the only words you need to follow a Jenkins conversation in a meeting or read
a pipeline at a new job.
controllerThe "brain" — stores
config, schedules jobs, hosts the web UI. Don’t run builds on it; it’s
a coordination role, not a worker.
agent / nodeA worker that actually
runs the build. Could be a static VM, a Docker container, or an ephemeral Kubernetes
pod created just for one job.
job / pipelineA unit of work. Modern
Jenkins prefers pipelines defined in a Jenkinsfile committed to the repo.
stageA named block in the pipeline,
shown on the visual graph (Build, Test, Deploy). Stages can run in parallel.
shared libraryReusable Groovy code
referenced from many pipelines. The way teams stop copy-pasting the same 200 lines into
every repo.
04Declarative vs scripted — pick declarative
Jenkins supports two pipeline syntaxes. The newer declarative one is what 95%
of teams should use 95% of the time.
Use it as your default. Cover 95% of real pipelines.
vs
Scripted
Raw Groovy.node { stage { sh "..." } }.
Unlimited power. Anything you can do in Groovy.
Unlimited rope. Easy to write unmaintainable spaghetti.
Use it only when declarative truly cannot express what you need.
05A Jenkinsfile a senior would ship
Ephemeral Kubernetes agent, parallel quality stages, image build and push, manual approval
before production. Read it top to bottom — this is what real pipelines look like.
Jenkins becomes a museum of past decisions if you let it. These habits keep it useful for
the next ten years.
Anti-pattern
Building on the controller. A build can compromise the controller and from
there the whole Jenkins. Builds belong on agents — ephemeral ones if possible.
Anti-pattern
Config in the UI. Jenkins click-ops is the most common reason a Jenkins server
becomes unmaintainable. Use Configuration-as-Code (JCasC) and Jenkinsfiles in the repo.
Anti-pattern
Stuck on Jenkins 2.222 forever. Old versions accumulate plugin vulnerabilities.
Stay on the current Long-Term-Support line. Treat Jenkins itself as a service you
patch.
Anti-pattern
Copy-paste pipelines across 50 repos. The day you need to change one thing, you
change it 50 times. Extract the common parts into a shared library.
Healthy
Kubernetes plugin for agents. A pod is created for each job and destroyed when
it finishes. Zero state between builds, zero idle hardware between bursts.
07Putting it together
Take-aways
1. Jenkins is the original CI / CD workhorse: open-source, self-hosted,
plugin-rich, regulator-friendly.
2. One controller, many agents. The controller coordinates; the agents
do the work. Never confuse the two.
3. Default to declarative pipelines in a Jenkinsfile in the repo.
Reach for scripted only when declarative truly cannot express it.
4. Stay on the LTS line, configure as code, run builds on ephemeral
agents. The server you set up that way will outlive several team rotations.
Next chapter: the CI / CD that comes built-in with your repository —
GitHub Actions.