CI/CD pipeline mental model in Jenkins - Step-by-Step Execution

Process Flow - CI/CD pipeline mental model

Code Commit

↓

Source Control

↓

Trigger Build

↓

Build Stage

↓

Test Stage

↓

Deploy Stage

↓

Production Release

↓

Feedback & Monitoring

↩Back to Code Commit

This flow shows how code changes move through stages: commit, build, test, deploy, release, and feedback, forming a continuous loop.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') { steps { echo 'Building...' } }
    stage('Test') { steps { echo 'Testing...' } }
    stage('Deploy') { steps { echo 'Deploying...' } }
  }
}

A simple Jenkins pipeline with Build, Test, and Deploy stages that run in order.

Process Table

Step	Stage	Action	Output	Next Step
1	Code Commit	Developer pushes code	Code stored in source control	Trigger Build
2	Trigger Build	Jenkins detects commit	Build job starts	Build Stage
3	Build	Compile and package code	Build successful	Test Stage
4	Test	Run automated tests	Tests passed	Deploy Stage
5	Deploy	Deploy to environment	Deployment successful	Production Release
6	Production Release	Release to users	New version live	Feedback & Monitoring
7	Feedback & Monitoring	Collect metrics and logs	Feedback collected	Code Commit
8	End	Loop continues	Pipeline ready for next commit	Cycle repeats

💡 Pipeline loops continuously after feedback to handle new code commits

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
Code State	No new code	Code committed	Code built	Code tested	Code deployed	Code released	Feedback collected	Ready for next commit
Pipeline Status	Idle	Building	Testing	Deploying	Releasing	Monitoring	Idle	Idle

Key Moments - 3 Insights

Why does the pipeline loop back to Code Commit after Feedback & Monitoring?

Because CI/CD pipelines are continuous, feedback triggers new code changes or fixes, restarting the cycle as shown in execution_table row 7.

What happens if tests fail during the Test stage?

The pipeline stops before Deploy stage to prevent bad code release, which would be visible as no transition from Test to Deploy in execution_table.

Is deployment automatic after tests pass?

Yes, in this model deployment happens automatically after successful tests, as shown in execution_table rows 4 and 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the pipeline status after Step 3?

A Building

B Testing

C Deploying

D Idle

💡 Hint

Check variable_tracker row 'Pipeline Status' after Step 3

At which step does the pipeline deploy the code?

A Step 5

B Step 6

C Step 4

D Step 7

💡 Hint

See execution_table row with Stage 'Deploy'

If tests fail, what change would you expect in the execution table?

A Pipeline skips Build stage

B Pipeline continues to Production Release

C Pipeline stops before Deploy stage

D Pipeline loops back to Feedback & Monitoring

💡 Hint

Refer to key_moments explanation about test failures

Concept Snapshot

CI/CD pipeline automates software delivery in stages:
1. Code Commit triggers pipeline
2. Build compiles code
3. Test verifies quality
4. Deploy releases code
5. Feedback monitors system
Cycle repeats continuously for fast, reliable delivery.

Full Transcript

A CI/CD pipeline is a continuous loop that starts when a developer commits code. Jenkins detects this and triggers a build stage to compile the code. If the build succeeds, automated tests run to check the code quality. Passing tests lead to deployment to an environment, followed by releasing the new version to users. Feedback and monitoring collect data to improve the next cycle. This loop repeats continuously to deliver software quickly and reliably.

Practice

1. What is the main purpose of a CI/CD pipeline in Jenkins?

easy

A. To manually run tests on software

B. To store software documentation

C. To write code faster

D. To automate building, testing, and deploying software

Solution

1. Step 1: Understand CI/CD pipeline role

   A CI/CD pipeline automates the process of building, testing, and deploying software to make delivery faster and more reliable.

2. Step 2: Identify Jenkins pipeline function

   Jenkins pipelines organize these automation steps into stages for clarity and control.

3. Final Answer:

   To automate building, testing, and deploying software -> Option D

4. Quick Check:

   CI/CD pipeline purpose = Automate build, test, deploy [OK]

Hint: CI/CD means automate build, test, deploy steps [OK]

Common Mistakes:

• Thinking CI/CD is for manual testing only
• Confusing pipeline with code writing
• Assuming pipeline stores documentation

2. Which of the following is the correct syntax to define a stage in a Jenkins declarative pipeline?

easy

A. stage: Build { steps: { echo 'Building...' } }

B. stage('Build') { steps { echo 'Building...' } }

C. stage = 'Build' { steps { echo 'Building...' } }

D. stage('Build') => { steps { echo 'Building...' } }

Solution

1. Step 1: Recall Jenkins declarative pipeline syntax

   In Jenkins declarative pipelines, stages are defined using stage('Name') { ... } syntax.

2. Step 2: Check each option's syntax

   stage('Build') { steps { echo 'Building...' } } uses correct syntax with parentheses and braces. Options B, C, and D use invalid symbols or assignment.

3. Final Answer:

   stage('Build') { steps { echo 'Building...' } } -> Option B

4. Quick Check:

   Correct stage syntax uses parentheses and braces [OK]

Hint: Stages use stage('name') { steps { ... } } syntax [OK]

Common Mistakes:

• Using colons instead of parentheses
• Assigning stage with = instead of defining block
• Using arrow => instead of braces

3. Given this Jenkins pipeline snippet, what will be the output?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        echo 'Starting tests'
        echo 'Tests passed'
      }
    }
  }
}

medium

A. Starting tests only

B. Tests passed\nStarting tests

C. Starting tests\nTests passed

D. No output, pipeline fails

Solution

1. Step 1: Analyze the pipeline steps

   The 'Test' stage has two echo commands executed in order: first 'Starting tests', then 'Tests passed'.

2. Step 2: Determine output order

   Jenkins runs steps sequentially, so output will be 'Starting tests' followed by 'Tests passed'.

3. Final Answer:

   Starting tests\nTests passed -> Option C

4. Quick Check:

   Echo commands run in order = Starting tests then Tests passed [OK]

Hint: Steps run top to bottom inside stage [OK]

Common Mistakes:

• Assuming output order is reversed
• Thinking only first echo runs
• Believing pipeline fails without error

4. Identify the error in this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Build')
      steps {
        echo 'Building...'
      }
  }
}

medium

A. Missing braces { } after stage('Build') declaration

B. Incorrect agent declaration

C. Missing echo command inside steps

D. Pipeline missing post section

Solution

1. Step 1: Check stage syntax

   The stage block must have braces { } after the stage name to enclose steps.

2. Step 2: Identify missing braces

   Here, stage('Build') is not followed by { }, causing a syntax error.

3. Final Answer:

   Missing braces { } after stage('Build') declaration -> Option A

4. Quick Check:

   Stage requires braces after name [OK]

Hint: Stage must have braces { } after name [OK]

Common Mistakes:

• Ignoring missing braces error
• Thinking agent declaration is wrong
• Assuming post section is mandatory

5. You want to create a Jenkins pipeline that builds your app only if tests pass. Which pipeline structure correctly models this CI/CD mental flow?

hard

A. stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } }

B. stages { stage('Build') { steps { echo 'Building...' } } stage('Test') { steps { echo 'Testing...' } } }

C. stages { stage('Build') { steps { echo 'Building...' } } post { always { echo 'Tests passed' } } }

D. stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } post { failure { error 'Tests failed' } } }

Solution

1. Step 1: Understand the requirement

   The app should build only if tests pass, requiring Test stage before Build stage to model the CI/CD flow where build follows successful tests.

2. Step 2: Analyze pipeline options

   stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } } places testing before building, correctly modeling the flow.

3. Step 3: Confirm other options

   stages { stage('Build') { steps { echo 'Building...' } } stage('Test') { steps { echo 'Testing...' } } } builds before tests (wrong order). stages { stage('Build') { steps { echo 'Building...' } } post { always { echo 'Tests passed' } } } wrong order and invalid post inside stages (syntax error). stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } post { failure { error 'Tests failed' } } } invalid post inside stages (syntax error).

4. Final Answer:

   stages { stage('Test') { steps { echo 'Testing...' } } stage('Build') { steps { echo 'Building...' } } } -> Option A

5. Quick Check:

   Test stage before Build = correct CI/CD order [OK]

Hint: Test stage before build stage [OK]

Common Mistakes:

• Building before testing
• Placing post inside stages (syntax error)
• Wrong order with post always