Overview

Jenkins is the grandfather of CI/CD — open source, self-hosted, and with 20 years of enterprise hardening. In 2026, it remains the top choice for organizations that require complete infrastructure control, air-gapped deployments, or have deep investments in its plugin ecosystem. Modern Jenkins uses Declarative Pipelines in Jenkinsfile, stored alongside code.

Declarative Pipeline

// Jenkinsfile
pipeline {
    agent any

    environment {
        NODE_VERSION = '20'
    }

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

        stage('Install') {
            steps {
                sh 'npm ci'
            }
        }

        stage('Test') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        sh 'npm run test:unit'
                    }
                }
                stage('Lint') {
                    steps {
                        sh 'npm run lint'
                    }
                }
            }
        }

        stage('Build') {
            steps {
                sh 'npm run build'
                archiveArtifacts artifacts: 'dist/**', fingerprint: true
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh './scripts/deploy.sh'
            }
        }
    }

    post {
        always {
            junit 'test-results/*.xml'
            cleanWs()
        }
        failure {
            slackSend channel: '#builds', message: "FAILED: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
    }
}

Docker-Based Agents

Run builds in containers for reproducibility:

pipeline {
    agent {
        docker {
            image 'node:20-alpine'
            args '-v /tmp:/tmp'  // Mount for caching
        }
    }

    stages {
        stage('Test') {
            steps {
                sh 'node --version'  // Runs inside container
                sh 'npm ci && npm test'
            }
        }
    }
}

Multi-Branch Pipeline

Jenkins automatically creates pipelines for every branch and PR:

// Configure in Jenkins UI: New Item → Multibranch Pipeline
// Jenkins scans the repo and creates a pipeline per branch

pipeline {
    agent any

    stages {
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }

        stage('Deploy Staging') {
            when {
                branch 'develop'
            }
            steps {
                sh 'kubectl apply -f k8s/staging/'
            }
        }

        stage('Deploy Production') {
            when {
                branch 'main'
            }
            input {
                message "Deploy to production?"
                ok "Deploy"
            }
            steps {
                sh 'kubectl apply -f k8s/production/'
            }
        }
    }
}

Shared Libraries

Reuse pipeline logic across repositories:

// vars/nodePipeline.groovy (in shared library repo)
def call(Map config = [:]) {
    pipeline {
        agent any
        stages {
            stage('Build & Test') {
                steps {
                    sh "npm ci"
                    sh "npm test"
                }
            }
        }
    }
}

// Jenkinsfile in your project (uses the shared library)
@Library('my-shared-lib') _
nodePipeline(nodeVersion: '20')

Jenkins vs Modern CI/CD

	Jenkins	GitHub Actions	CircleCI
Hosting	Self-managed	Cloud	Cloud/Self
Setup time	Hours/days	Minutes	Minutes
Plugin ecosystem	1,800+ plugins	20,000+ actions	Orbs
Control	Complete	Limited	Limited
Maintenance burden	High	None	Low
Cost model	Infrastructure only	Minutes-based	Credits

Jenkins wins when: compliance requires on-premise, you have existing investment in it, or you need integrations not available in cloud CI/CD platforms.

Jenkins — Open-Source Automation Server for CI/CD

✅ Pros

⚠️ Cons