How to Build and Automate With Jenkins CI/CD Pipeline

Still using manual deployment in 2025? Master the Jenkins CI/CD pipeline to automate builds, reduce errors, and speed up delivery. This blog covers setup, pipelines, integrations, and practical tips for real-world projects.

Still deploying code manually and hoping everything goes right? That may have worked in the past, but today, it slows teams down and leaves too much room for error. Fast-moving development cycles demand speed, consistency, and reliability from the start.

So, how do you deliver high-quality software without compromising on stability?

Manual processes introduce delays and bugs that modern teams can't afford. That's why many are turning to automation, and Jenkins leads the way. With the right Jenkins CI/CD pipeline, you can automate builds, reduce mistakes, and ship with confidence.

This article guides you through the process of installing Jenkins, building both declarative and scripted pipelines, integrating tools such as Git and Maven, and optimizing your pipeline for enhanced performance and scalability.

What is Jenkins CI/CD Pipeline?

The Jenkins CI/CD pipeline is a series of automated steps to build, test, and deploy your software. It integrates continuous integration (CI), where developers frequently merge code, with continuous delivery (CD), ensuring that validated code is always ready for release. Jenkins, as an open-source automation server, facilitates this process using a pipeline plugin, enabling teams to treat deployment workflows as code.

Why Use Jenkins Pipeline?

Using a Jenkins pipeline brings several benefits:

• Automates repetitive tasks like testing and deployment.

• Improves visibility with detailed console output and build history.

• Supports both declarative and scripted pipelines, accommodating different use cases.

• Integrates with a wide range of tools, including Git, Docker, Maven, and Tomcat.

• Enables parallel stages, conditional logic, and robust error handling.

Key Jenkins Pipeline Concepts

Installing Jenkins

To install Jenkins, follow these steps:

1. Download from the official Jenkins site.

2. Run using java -jar jenkins.war.

3. Access the Jenkins web UI at http://localhost:8080.

4. Retrieve the initial admin password from the terminal or the initialAdminPassword file.

5. Install suggested plugins or choose from a few options manually.

6. Create the first admin user and configure the Jenkins URL.

This process sets up your Jenkins server and gets you ready to create Jenkins jobs.

Declarative vs Scripted Pipelines

Jenkins supports two pipeline syntaxes: declarative pipeline and scripted pipeline.

Let’s break them down.

Declarative Pipeline

• Structured and beginner-friendly.

• Uses the pipeline block with nested stages.

• Ideal for most CI/CD setups.

Example:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
            }
        }
    }
}

Scripted Pipeline

• Written in full Groovy, offering more flexibility.

• Uses the node block to define steps.

• Better for advanced users or complex logic.

Example:

Copy
1
2
3
4
5
6
7
8
9
10
11
node {
    stage('Build') {
        echo 'Building...'
    }
    stage('Test') {
        echo 'Testing...'
    }
    stage('Deploy') {
        echo 'Deploying...'
    }
}

Both syntaxes support pipeline-as-code via a Jenkinsfile stored in a Git repository, which keeps your pipeline definition under source control.

“I’ve just shared a detailed guide on setting up a CI/CD pipeline using Jenkins and Docker, and it’s helping developers automate deployments with ease.”

— Shahid Shaikh, via LinkedIn

Building a CI/CD Pipeline in Jenkins

To set up a basic CI CD pipeline, follow these steps:

1. Create a New Pipeline Job

• Go to the Jenkins web UI.

• Click "New Item", name it, and select Pipeline.

2. Add a Jenkinsfile

Use a text file named Jenkinsfile in your project root with this sample pipeline code:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
pipeline {
    agent any
    environment {
        ENV = 'staging'
    }
    stages {
        stage('Checkout') {
            steps {
                git '<https://github.com/example/repo.git>'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
                echo 'Building...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                sh 'scp target/app.war user@server:/path/to/tomcat/webapps'
            }
        }
    }
}

3. Build and Monitor

• Click Build Now.

• Track progress in console output or Jenkins dashboard.

Real-World Example: Java Web App Deployment

Let’s see a delivery pipeline example using:

• Git repository for source code.

• Maven for building.

• SonarQube for code analysis.

• Nexus for artifact storage.

• Apache Tomcat for deployment.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/your-org/project.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
                echo 'Echo building project'
            }
        }
        stage('SonarQube Analysis') {
            steps {
                withSonarQubeEnv('SonarQube') {
                    sh 'mvn sonar:sonar'
                }
            }
        }
        stage('Upload to Nexus') {
            steps {
                nexusArtifactUploader(...)
            }
        }
        stage('Deploy to Tomcat') {
            steps {
                echo 'Echo deploying to Tomcat'
            }
        }
    }
}

This pipeline shows real-world integration of continuous delivery pipelines, leveraging the power of Jenkins and popular DevOps tools.

Best Practices and Tips

• Use a multibranch pipeline for managing multiple branches.

• Store your Jenkinsfile in the same git repository as your code.

• Handle test failures and show results via junit reports.

• Use conditional logic for environment-specific deployments.

• Always define environment variables securely.

• Use the pipeline syntax generator from the Jenkins UI for help.

• Clean up the Jenkins home directory periodically to free space.

• Monitor previous run failed statuses and handle them gracefully.

Summary: Declarative vs Scripted Pipelines

Accelerate Your Software Delivery with Confidence

The Jenkins CI/CD pipeline transforms how software teams handle integration, testing, and deployment. By automating repetitive tasks , maintaining consistency across environments, and integrating seamlessly with essential tools, Jenkins eliminates the delays and errors of manual workflows. Whether you're using declarative pipeline syntax for clarity or scripted pipeline logic for flexibility, this approach streamlines your software delivery process from commit to production.

As release cycles shorten and expectations increase, mastering Jenkins is no longer optional; it’s a strategic necessity. It enables you to adapt quickly, deliver quality software faster, and scale your DevOps practices efficiently.

Start building your first pipeline, refine your workflows, and take control of your CI CD pipeline today. The path to reliable, automated delivery starts here.