What is a Jenkins Pipeline

Section I gave you the foundation. Section II is where Jenkins gets real. Pipelines are how professionals automate software delivery — and the Jenkinsfile is the file that makes it all possible.

In Section I, you built a Freestyle job by clicking through forms in Jenkins. That worked — but the configuration only existed inside Jenkins. If Jenkins went down, the job was gone. If a colleague wanted to see what the job did, they had to log into Jenkins and click around. There was no history of who changed what. No way to review a change before it went live.

A Jenkins Pipeline solves all of that. The entire build process is defined in a single file — the Jenkinsfile — that lives in your code repository alongside your application. It travels with your code. It gets reviewed in pull requests. It gets versioned in Git. And it runs the same way on any Jenkins server that picks it up.

The Three Building Blocks of Every Pipeline

No matter how complex a Jenkins Pipeline gets, it is always built from the same three things:

What a Pipeline Looks Like in the Jenkins UI

When a Pipeline job runs, Jenkins shows you a visual stage view — each stage as a box, colour-coded by result. This is the view you'll stare at while waiting for a deployment to finish. Here's what it looks like:

And here's what it looks like when a stage fails — Jenkins stops at the red stage and shows you exactly where to look:

Your First Jenkinsfile

The scenario:

You're a backend developer at a SaaS startup. Your team has been deploying the notification-service manually for months. You've been asked to write the first Jenkinsfile for this service — one that checks out the code, runs tests, and prints a success message. Simple, clean, and something the whole team can build on top of.

New terms introduced in this code:

• Jenkinsfile — a text file named exactly Jenkinsfile (capital J, no extension) that lives in the root of your code repository. This is the file Jenkins reads to know what your pipeline should do.
• Declarative Pipeline syntax — the modern, recommended way to write Jenkinsfiles. It has a strict, readable structure. You'll learn the older Scripted syntax in Lesson 12 so you understand the difference.
• pipeline { } — the outermost block. Everything in your Jenkinsfile lives inside this block.
• agent any — tells Jenkins to run this pipeline on any available agent. You can replace any with a specific label like agent { label 'linux' } to target a specific machine.
• stages { } — the container that holds all your stage blocks.
• stage('Name') { } — a named phase of your pipeline. The name appears in the Jenkins UI stage view.
• steps { } — the container inside a stage where you put the actual commands to run.
• sh — runs a shell command on the agent. This is the most common step — it's how you run tests, build commands, and deployment scripts.
• echo — prints a message to the console output. Useful for logging what your pipeline is doing.
• post { } — runs after all stages. success runs only if everything passed. failure runs only if something failed. always runs no matter what.

// This is a Declarative Pipeline — the modern standard for Jenkins
// Save this file as 'Jenkinsfile' in the root of your repository
pipeline {

    // Run on any available agent (we'll get specific about agents in Lesson 14)
    agent any

    // 'stages' is the container that holds all your pipeline stages
    stages {

        // Stage 1: Pull the latest code from the repository
        stage('Checkout') {
            steps {
                // 'checkout scm' tells Jenkins to pull the code from whatever
                // source control repo triggered this build
                checkout scm
                echo 'Code checked out successfully'
            }
        }

        // Stage 2: Run the test suite
        stage('Test') {
            steps {
                // 'sh' runs a shell command on the agent
                // './gradlew test' is the Gradle command to run all tests
                sh './gradlew test'
            }
        }

        // Stage 3: Confirm everything passed
        stage('Complete') {
            steps {
                echo 'All stages passed — notification-service is healthy'
            }
        }

    }

    // 'post' runs after all stages, regardless of what happened
    post {
        // 'success' only runs if every stage above passed
        success {
            echo 'Pipeline finished successfully — ready to deploy'
        }
        // 'failure' only runs if a stage above failed
        failure {
            echo 'Pipeline failed — check the Test stage for details'
        }
    }

}

Started by user admin
[Pipeline] Start of Pipeline
[Pipeline] node
Running on agent-linux-01 in /var/jenkins_home/workspace/notification-service
[Pipeline] {
[Pipeline] stage
[Pipeline] { (Checkout)
[Pipeline] checkout
Cloning repository https://github.com/acmecorp/notification-service.git
 > git checkout main
[Pipeline] echo
Code checked out successfully
[Pipeline] }
[Pipeline] stage
[Pipeline] { (Test)
[Pipeline] sh
+ ./gradlew test
BUILD SUCCESSFUL in 54s
28 tests completed, 0 failed
[Pipeline] }
[Pipeline] stage
[Pipeline] { (Complete) }
[Pipeline] echo
All stages passed — notification-service is healthy
[Pipeline] }
[Pipeline] stage (post)
[Pipeline] echo
Pipeline finished successfully — ready to deploy
[Pipeline] End of Pipeline
Finished: SUCCESS

Creating a Pipeline Job in the Jenkins UI

Here's exactly how you wire up your Jenkinsfile to a Jenkins Pipeline job — step by step in the UI:

Why Pipeline-as-Code Changes Everything

Practice Questions

Quiz