CI/CD for Beginners: Jenkins, GitHub Actions & Docker Explained

CI/CD is an important concept for modern software development, DevOps, QA automation and SDET roles. If you are preparing for an IT job, learning CI/CD can help you understand how code moves from a developer's machine through testing and toward deployment.

This beginner-friendly guide explains Continuous Integration, Continuous Delivery, Continuous Deployment, Jenkins, GitHub Actions, Docker and automated testing with practical examples.

By the end, you will understand how these technologies can work together in a practical QA and SDET workflow.

Quick Summary

Understand the difference between CI, Continuous Delivery and Continuous Deployment.
Learn how Jenkins can automate builds, tests and deployments.
Understand GitHub Actions workflows and runners.
Learn the role of Docker images, containers and Dockerfiles.
See how Selenium and Playwright automation can run in CI/CD.
Follow a practical learning roadmap and beginner project.

What Is CI/CD?

CI/CD stands for Continuous Integration and Continuous Delivery/Continuous Deployment.

It is a software development practice that helps teams automate activities such as:

Building applications
Running automated tests
Checking code quality
Creating application packages
Building Docker images
Deploying applications
Generating test reports

Instead of manually performing every step whenever developers make changes, CI/CD tools can automate the workflow.

Key Takeaway: CI/CD creates an automated path from source-code changes through build, testing and, when configured, delivery or deployment.

Simple CI/CD Example

Imagine a developer changes the login functionality of an application. A typical CI/CD workflow could look like this:

Developer changes the code

↓

Code is pushed to GitHub

↓

CI/CD pipeline starts

↓

Application is built

↓

Automated tests execute

↓

Reports are generated

↓

Docker image is created

↓

Application is deployed to a test environment

Additional tests can then be executed against the deployed environment. This automation reduces repetitive manual work and provides faster feedback to the development team.

Continuous Integration (CI)

Continuous Integration means developers frequently integrate their code changes into a shared repository and automated checks are performed.

Example: A developer pushes code to GitHub. The CI pipeline checks out the code, builds the project, executes automated tests and produces a test result.

Developer

↓

Git Push

↓

CI Pipeline

↓

Build

↓

Automated Tests

↓

Test Report

If the tests fail, the team can investigate the failure earlier in the development process.

Continuous Delivery vs Continuous Deployment

These two terms are related but are not exactly the same.

Concept	Meaning
Continuous Integration	Frequently integrate code and automatically test it.
Continuous Delivery	Keep software ready for deployment after required checks. A human may still approve production deployment.
Continuous Deployment	Automatically deploy approved changes when the required checks pass.

Continuous Delivery

Continuous Delivery means the application is automatically prepared for release after passing the required checks. A human may still approve the production deployment.

Continuous Deployment

Continuous Deployment takes automation one step further. If all required checks pass, the application can automatically be deployed to production.

Why Should Testers Learn CI/CD?

CI/CD is especially useful for QA engineers, automation testers and SDETs because automated tests are commonly executed as part of CI/CD pipelines.

For example, a Selenium or Playwright test suite can be triggered automatically whenever new code is pushed.

What Should a QA Engineer Understand?

How a pipeline starts
How test suites are executed
How test reports are generated
How failures are identified
How environment variables are configured
How test results are stored
How Docker can provide consistent test environments

💡 Pro Tip: If you are preparing for an SDET role, do not only memorize CI/CD definitions. Build a small automation project and make the tests run automatically through a pipeline.

Popular CI/CD Tools

Tool	Common Usage
Jenkins	CI/CD automation and pipelines
GitHub Actions	Automation directly inside GitHub repositories
GitLab CI/CD	CI/CD within GitLab
Azure Pipelines	CI/CD for Azure and other environments
CircleCI	Cloud-based CI/CD automation

What Is Jenkins?

Jenkins is an automation server commonly used to create and execute CI/CD pipelines. Jenkins documentation describes it as an automation server that can automate activities such as building, testing and delivering or deploying software.

It can automatically perform tasks such as:

Downloading source code
Installing dependencies
Building applications
Running automated tests
Generating reports
Building Docker images
Deploying applications

How Jenkins Works

Git Repository

↓

Jenkins Trigger

↓

Checkout Code

↓

Build

↓

Run Tests

↓

Generate Reports

↓

Deploy

Jenkins Pipeline

A Jenkins Pipeline defines the steps Jenkins should execute. Jenkins supports Pipeline-as-Code through a Jenkinsfile stored with the project.

A basic pipeline may contain stages such as:

pipeline { stages { stage('Checkout') { steps { // Get source code } } stage('Build') { steps { // Build application } } stage('Test') { steps { // Run automated tests } } stage('Deploy') { steps { // Deploy application } } } }

The exact pipeline syntax depends on the project and tools being used.

Official Jenkins Resource: Learn more about Jenkins Pipeline in the official Jenkins Pipeline documentation.

Jenkins for QA Automation

Suppose you have a Selenium Java project using Maven. Jenkins can execute a command such as:

mvn clean test

This command can be integrated into a Jenkins job or pipeline so that automated tests run as part of the CI workflow.

For a Playwright TypeScript project, a pipeline could execute commands such as:

npm ci npx playwright test

The generated test results can then be published or stored as pipeline artifacts, depending on the CI/CD configuration.

Advantages of Jenkins

Highly customizable
Large plugin ecosystem
Supports many programming languages
Works with Git repositories
Can execute automated test suites
Can integrate with Docker
Can be used for complex enterprise pipelines

Example: A Selenium Java framework can be stored in Git, checked out by Jenkins, built with Maven and executed automatically. Test results can then be preserved or published according to the project's reporting setup.

What Is GitHub Actions?

GitHub Actions is a workflow automation platform integrated into GitHub. It allows you to automate tasks directly from your GitHub repository.

GitHub Push

↓

GitHub Actions

↓

Install Dependencies

↓

Run Tests

↓

Generate Report

Workflows are commonly stored inside:

.github/workflows/

Workflow files use YAML syntax.

Simple GitHub Actions Example

name: Automated Tests on: push: pull_request: jobs: test: runs-on: ubuntu-latest steps: - name: Checkout Code uses: actions/checkout@v4 - name: Setup Node.js uses: actions/setup-node@v4 - name: Install Dependencies run: npm ci - name: Run Tests run: npm test

When a configured event occurs, GitHub Actions can start this workflow automatically.

Understanding a GitHub Actions Workflow

1. Workflow Name

name: Automated Tests

This gives the workflow a readable name.

2. Trigger

on: push: pull_request:

This specifies when the workflow should run.

3. Job

jobs: test:

A job contains the tasks that GitHub Actions should execute.

4. Runner

runs-on: ubuntu-latest

The runner provides the environment where the workflow commands execute.

5. Steps

Steps define individual operations such as checking out code, installing dependencies and running tests.

Official GitHub Resource: GitHub provides detailed documentation for workflow syntax, including workflows, jobs and steps.

Jenkins vs GitHub Actions

Feature	Jenkins	GitHub Actions
Type	Automation server	GitHub-integrated automation
Configuration	Jenkins UI / Jenkinsfile	YAML workflow files
GitHub Integration	Requires configuration	Built into GitHub
Customization	Highly customizable	Highly configurable
Plugins / Actions	Plugins	Actions
Infrastructure	Often self-managed	Can use hosted or self-hosted runners

What Is Docker?

Docker is a platform used to package applications and their dependencies into containers.

A container provides an isolated environment in which an application can run consistently.

For beginners, think of Docker as a way to package:

Application code
Required libraries
Runtime dependencies
Configuration

into a portable container image.

Why Is Docker Important in CI/CD?

Without consistent environments, an application may work on one machine but behave differently on another.

Docker can help reduce environment-related differences by providing consistent application and testing environments.

Developer Machine

↓

Docker Image

↓

CI Pipeline

↓

Test Container

↓

Deployment Environment

Docker Image vs Container

Term	Meaning
Docker Image	Packaged template used to create containers.
Docker Container	Running instance created from an image.
Dockerfile	Instructions used to build an image.
Docker Registry	Repository used to store and distribute images.

💡 Pro Tip: Do not confuse an image with a running container. An image is used as the packaged basis for creating containers.

Basic Docker Commands

Some useful Docker commands for beginners are:

# Check Docker version docker --version # Download an image docker pull nginx # List images docker images # Run a container docker run nginx # List running containers docker ps # Stop a container docker stop <container-id> # Remove a container docker rm <container-id>

What Is a Dockerfile?

A Dockerfile contains instructions for creating a Docker image.

FROM node:22 WORKDIR /app COPY package*.json ./ RUN npm ci COPY . . CMD ["npm", "test"]

This example starts from a Node.js image, creates a working directory, installs project dependencies, copies the project and runs the test command.

Official Docker Resource: You can learn more about Docker and Dockerfiles from Docker's official Getting Started guide and the Dockerfile documentation.

Docker in a Testing Project

Docker can be useful for QA and SDET teams in several ways.

Running test environments
Running databases for testing
Running Selenium infrastructure
Running Playwright test environments
Creating consistent CI environments
Running services required by integration tests

CI/CD + Docker + Automated Testing

These technologies can work together in a single workflow.

Developer

↓

GitHub

↓

Jenkins / GitHub Actions

↓

Build Application

↓

Docker Build

↓

Run Containers

↓

Execute Automated Tests

↓

Generate Reports

↓

Deploy

Example: Selenium Java Project in CI/CD

Suppose you have a Selenium Java automation project using Maven.

Your repository might look like:

selenium-project/ │ ├── src/ │ ├── main/ │ └── test/ │ ├── pom.xml ├── testng.xml ├── Jenkinsfile └── README.md

The CI pipeline could perform these steps:

Checkout the Git repository.
Install the required Java version.
Install Maven dependencies.
Execute the test suite.
Generate test reports.
Store test artifacts.
Notify the team if the pipeline fails.

The command could be:

mvn clean test

Official Selenium Resource: Selenium provides official documentation for WebDriver and getting started with browser automation: Selenium Documentation.

Example: Playwright TypeScript in CI/CD

For a Playwright TypeScript project, a pipeline could perform:

npm ci npx playwright install --with-deps npx playwright test

After execution, the pipeline can preserve test reports and screenshots as artifacts, depending on the CI/CD configuration.

Playwright's official CI documentation provides examples for running Playwright tests with GitHub Actions and installing the required browsers and dependencies.

Official Playwright Resource: Playwright Continuous Integration documentation.

Key Takeaway: Selenium and Playwright are not separate from CI/CD. They can become automated testing stages inside the pipeline.

What Is a CI/CD Pipeline?

A pipeline is an automated sequence of tasks used to build, test and potentially deploy software.

Stage	Example Activity
Checkout	Get source code
Build	Compile or package application
Unit Test	Run unit tests
Integration Test	Test service interactions
Automation Test	Run Selenium, Playwright or API tests
Package	Create application or Docker image
Deploy	Deploy to the target environment

CI/CD Pipeline for an SDET

An SDET may interact with several stages of a pipeline.

Code Push

↓

Build

↓

Unit Tests

↓

API Tests

↓

UI Automation

↓

Reports

↓

Docker Image

↓

Deployment

This is why modern SDET roles can involve Git, CI/CD, automation frameworks and Docker.

Related DVGHM Guide: SDET Interview Preparation Roadmap

Practical CI/CD Project for Beginners

If you want to learn CI/CD properly, building a small project is more useful than only memorizing definitions.

You can create a simple automation project using:

Java
Selenium
TestNG
Maven
Git
GitHub
Jenkins
Docker

Create Automation Tests

Create a Selenium automation framework using Java, TestNG and Maven.

Push the Project to GitHub

Use Git to commit your code and push it to a GitHub repository.

Configure Jenkins

Configure Jenkins to retrieve the repository and execute the Maven test command.

mvn clean test

Generate Reports

Configure your pipeline to preserve or publish the test results generated by your framework.

Add Docker

Create a Dockerfile or use suitable testing containers to make the execution environment more consistent.

Automate the Pipeline

Configure the pipeline to execute when changes are pushed or when the project is scheduled to run.

Beginner Project Goal: By completing this project, you will have practical experience connecting source control, automation testing, CI/CD and Docker in one workflow.

Related DVGHM Guide: Git & GitHub for Beginners

Recommended CI/CD Learning Roadmap

Stage	Topics to Learn
1	CI/CD fundamentals
2	Linux basics and command line
3	Git and GitHub
4	Jenkins basics
5	Jenkins pipelines and Jenkinsfile
6	GitHub Actions
7	Docker fundamentals
8	Dockerfile and Docker images
9	Run automated tests through CI/CD
10	Build a complete project

Related DVGHM Guide: Manual Testing Roadmap for Freshers

7-Day CI/CD Learning Plan

Day	Learning Focus
Day 1	CI/CD concepts and pipeline fundamentals
Day 2	Git commands and GitHub workflow
Day 3	Jenkins installation and basic jobs
Day 4	Jenkins pipelines and Jenkinsfile
Day 5	GitHub Actions and YAML workflows
Day 6	Docker images, containers and Dockerfile
Day 7	Build a complete automation CI/CD project

Common CI/CD Interview Questions

1. What is CI/CD?

CI/CD is a software development practice that automates activities such as integrating code, building applications, testing and delivering or deploying software.

2. What is Jenkins?

Jenkins is an automation server commonly used to implement CI/CD pipelines.

3. What is GitHub Actions?

GitHub Actions is a workflow automation platform integrated with GitHub repositories.

4. What is a Jenkinsfile?

A Jenkinsfile is a file that defines a Jenkins pipeline as code.

5. What is Docker?

Docker is a platform used to package and run applications in containers.

6. What is the difference between a Docker image and a container?

A Docker image is a packaged template, while a container is a running instance created from an image.

7. How can Selenium tests be executed through Jenkins?

A Jenkins pipeline can check out the automation project, install dependencies and execute the configured test command, such as a Maven or Gradle command.

8. Why is Docker useful in CI/CD?

Docker can provide repeatable and isolated environments for applications, services and automated tests.

9. What happens when a CI pipeline fails?

The pipeline normally reports the failed stage. Teams can inspect logs and test results to identify and fix the problem.

10. What should an SDET know about CI/CD?

An SDET should understand Git workflows, pipeline stages, automated test execution, reports, environment variables, build tools, Jenkins or GitHub Actions and basic Docker concepts.

Common Mistakes Beginners Make

Trying to learn Kubernetes before understanding Docker.
Memorizing Jenkins commands without building a pipeline.
Learning CI/CD without understanding Git.
Ignoring Linux command-line basics.
Running automation tests manually instead of integrating them into a pipeline.
Not understanding pipeline logs.
Creating a complex pipeline before learning simple CI workflows.

⚠️ Important: CI/CD is a practical skill. Start with a simple pipeline and gradually add testing, reports, containers and deployment stages.

How CI/CD Fits Into a Real QA Project

In a typical Agile project, developers frequently push code changes to the source-control repository.

The CI/CD system can then automatically build the application and execute different levels of testing.

Developer Commit

↓

Git Repository

↓

CI Trigger

↓

Build

↓

Unit Tests

↓

API Tests

↓

UI Automation

↓

Test Reports

↓

Deployment

↓

Smoke Tests

QA engineers and SDETs can therefore become part of the development pipeline instead of running tests only at the end of a release cycle.

CI/CD Checklist for Beginners

Understand Continuous Integration.
Understand Continuous Delivery and Deployment.
Learn Git basics.
Learn GitHub workflows.
Learn Linux commands.
Install and use Jenkins.
Create a Jenkins pipeline.
Learn Jenkinsfile basics.
Create a GitHub Actions workflow.
Learn Docker images and containers.
Write a basic Dockerfile.
Run automated tests in CI/CD.
Generate and preserve test reports.
Build at least one complete project.

Frequently Asked Questions

Is CI/CD difficult for beginners?

The terminology can seem complicated initially, but the basic workflow is straightforward: code is pushed, the pipeline builds the project, tests are executed and the result is reported.

Should I learn Jenkins or GitHub Actions first?

Learn the underlying CI/CD concepts first and then practice with one tool. Jenkins is widely used in many enterprise environments, while GitHub Actions is convenient when your source code and workflows are hosted on GitHub.

Should testers learn Docker?

Docker is useful for testers and SDETs because modern automation and CI/CD environments frequently use containers for repeatable test and application environments.

Do I need Kubernetes to learn CI/CD?

No. Kubernetes is not required to understand the fundamentals of CI/CD. Learn Git, CI/CD concepts, Jenkins or GitHub Actions and Docker first.

Can Selenium tests run in Jenkins?

Yes. Selenium automation projects can be integrated into Jenkins pipelines so that tests execute automatically as part of the CI workflow.

Can Playwright tests run in GitHub Actions?

Yes. Playwright projects can be configured in GitHub Actions workflows to install dependencies, install required browsers and execute automated tests.

Official Resources

Keep Learning

Explore more career, technology and interview preparation guides on DVGHM to continue building your IT skills.

Final Thoughts

CI/CD is an important skill for developers, DevOps engineers, QA automation engineers and SDETs. You do not need to learn every DevOps tool at once.

Start with the fundamentals:

Git → CI/CD Concepts → Jenkins/GitHub Actions → Docker → Automated Testing → Complete Pipeline Project

Once you understand this workflow, you can gradually move toward advanced topics such as cloud deployments, infrastructure automation, Kubernetes and advanced DevOps practices.