Jenkins

The original CI / CD workhorse. Still installed in tens of thousands of enterprises — and still the fastest way to get hired into one.

Controller UI · CONFIG · ORCHESTRATION Linux agent docker · java · node Windows agent .net · msbuild Kubernetes pod ephemeral · per-job
Topology One controller · many ephemeral agents

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.

Declarative

  • Structured. pipeline { agent { } stages { } } — fixed shape.
  • Lints in the editor. Predictable for reviewers.
  • Easier to learn. Less Groovy magic.
  • 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.

Jenkinsfiledeclarative
pipeline {
  agent { kubernetes { yamlFile 'agents/node20.yaml' } }

  options {
    timeout(time: 30, unit: 'MINUTES')
    timestamps()
    ansiColor('xterm')
    buildDiscarder(logRotator(numToKeepStr: '30'))
  }

  environment {
    REGISTRY = 'ghcr.io/you'
    IMAGE    = "${REGISTRY}/web:${env.BUILD_NUMBER}"
  }

  stages {
    stage('Checkout') {
      steps { checkout scm }
    }

    stage('Quality') {
      parallel {
        stage('Lint') { steps { sh 'npm run lint' } }
        stage('Test') { steps { sh 'npm test -- --coverage' } }
        stage('SAST') { steps { sh 'npx semgrep --config p/ci' } }
      }
    }

    stage('Build & push') {
      steps {
        sh 'docker build -t $IMAGE .'
        withCredentials([usernamePassword(credentialsId: 'ghcr',
            usernameVariable: 'U', passwordVariable: 'P')]) {
          sh 'echo $P | docker login ghcr.io -u $U --password-stdin'
        }
        sh 'docker push $IMAGE'
      }
    }

    stage('Deploy prod') {
      when { branch 'main' }
      steps {
        input message: 'Promote to production?'
        sh 'kubectl set image deploy/web web=$IMAGE -n prod'
      }
    }
  }

  post {
    failure {
      mail to: 'team@example.com',
           subject: "FAIL ${env.JOB_NAME}",
           body: env.BUILD_URL
    }
  }
}

06Habits that keep Jenkins healthy

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.