Build a CI/CD Pipeline with GitHub Actions

Automate code testing on every push using GitHub Actions and Node.js.

Introduction

30 Second Summary

Imagine pushing code to your team's project and finding out hours later that you accidentally broke something. In the real world, developers avoid this by using automated pipelines that test every code change the moment it's submitted.

In this project, you will build your first CI/CD pipeline using GitHub Actions. You'll create a small Node.js application, write automated tests for it, and set up a pipeline that runs those tests every time you push code.

What You'll Build

A fully automated CI pipeline that validates your code on every push to GitHub, using a Node.js project with tests and a GitHub Actions workflow file.

By the end of this project, you'll have:

  • A Node.js project with a utility module and an automated test suite.
  • A GitHub Actions workflow that triggers on every push to your repository.
  • A proven pipeline that you've seen both pass and fail, confirming it catches bugs automatically.
  • Secret Mission: Add automated linting to enforce code quality in your pipeline.

Are there any prerequisites?

None. This guide walks you through installing every tool you need, including Git, Node.js, and VS Code. All you need is a Mac with internet access.

Install Git and Node.js

Before writing any code, you need three tools on your Mac.

Git tracks changes in your code. Node.js runs your JavaScript project and its tests. VS Code is the editor where you write and manage your files.

In this step, get ready to:
  • Install Git via Xcode Command Line Tools.
  • Install Node.js v24 LTS.
  • Install VS Code.
Install Git

Git comes bundled with Apple's Xcode Command Line Tools. Installing these tools gives you Git plus other developer utilities your Mac needs.

  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Terminal and press Enter to open it.
  • Install the Xcode Command Line Tools by running this command:
xcode-select --install

What happens next?

A dialog box will pop up outside your Terminal window asking if you want to install the command line developer tools. Click Install and wait for the download to finish. This can take a few minutes.

If you see the message command line tools are already installed instead, you already have Git. Skip straight to the verification step below.

  • Once the installation finishes, verify Git is working by running:
git --version

✔️ I see a version number

You should see something like git version 2.x.x. The exact number does not matter. Git is ready to go.

ⓧ It's not installed yet

If you see an error or another popup appears asking to install developer tools, the installation did not complete.

  • Click Install in the popup dialog and wait for it to finish.
  • Run git --version again after the install completes.

If you still get an error, help me troubleshoot my Git installation on macOS.

Install Node.js

Node.js is the runtime that executes your JavaScript code outside of a browser. It also comes with npm, a package manager you will use to install dependencies and run your test scripts.

  • Open https://nodejs.org in your browser.
  • Click the download button for the LTS version (v24).
  • Open the downloaded .pkg file and follow the installer prompts. Accept the defaults at each screen.
  • Verify Node.js is installed by running:
node --version
  • Verify npm is available by running:
npm --version

✔️ I see version numbers

You should see v24.x.x for Node.js and 10.x.x (or higher) for npm. The exact patch numbers do not matter. Node.js and npm are ready.

ⓧ Command not found

If Terminal does not recognize the command, the installer may not have finished or your Terminal session needs refreshing.

  • Close your Terminal window completely and open a new one.
  • Run node --version again.
  • If it still fails, re-download the installer from nodejs.org and run it again.

Still stuck? Help me troubleshoot my Node.js installation on macOS.

Install VS Code

VS Code is a free code editor. You will use it to write your project files, run Terminal commands, and manage your Git workflow all in one place.

  • Open https://code.visualstudio.com in your browser.
  • Click the download button for macOS. This downloads a .zip file.
  • Open the downloaded .zip file. It extracts the VS Code application automatically.
  • Drag Visual Studio Code.app into your Applications folder.
  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Visual Studio Code and press Enter to open it.

First time opening VS Code?

macOS may show a warning that VS Code was downloaded from the internet. Click Open to confirm. You only see this once.

VS Code not opening?

Make sure you dragged the app into Applications and not another folder. If the app bounces in the dock and disappears, try right-clicking it in Applications and selecting Open.

Still stuck? Help me get VS Code running on my Mac.

Your development environment is ready. Next up, you will create a GitHub account and set up the repository that your pipeline will monitor.

Create a GitHub Account and Repository

Your tools are installed and ready to go. Now you need a place to store your code online so that GitHub Actions can access it and run your pipeline automatically.

GitHub is where your code lives and where your CI pipeline will run. In this step, you will create a repository on GitHub, then clone it to your Mac so you can work on it locally.

In this step, get ready to:
  • Create a GitHub account (or sign in to your existing one).
  • Create a public repository to host your project.
  • Clone the repository to your Mac and open it in VS Code.
Create your GitHub account

GitHub is a free platform that hosts your code repositories and runs your CI/CD pipelines. You need an account to create repositories and use GitHub Actions.

  • Open your browser and go to github.com.
  • If you already have a GitHub account, click Sign in and log in with your credentials.
  • If you do not have an account, click Sign up and follow the prompts to create a free account.

What plan do I need?

The free GitHub plan is all you need. Public repositories get unlimited GitHub Actions minutes at no cost.

Create a new public repository

A repository is a project folder that GitHub hosts for you. Your pipeline will watch this repository and run tests every time you push new code to it.

  • In the top-right corner of GitHub, click the + icon.
  • Select New repository.
  • In the Repository name field, type my-first-pipeline.
  • Select Public for the repository visibility.
  • Check the box labeled Add a README file.
  • Click Create repository.

GitHub redirects you to your new repository page. You should see a README.md file displayed with your repository name as the heading.

Why does the repository need to be public?

Public repositories get unlimited free GitHub Actions minutes. Private repositories on the free plan are limited to 2,000 minutes per month.

Don't see the Create repository button?

Make sure you have typed a repository name. GitHub disables the button until the name field is filled in.

If you see a message saying the name is already taken, you may already have a repository with this name. Delete it first or choose a different name.

Help me create my GitHub repository.

Clone the repository and open it in VS Code

Cloning downloads a copy of your GitHub repository to your Mac. This lets you edit code locally and push changes back to GitHub, which triggers your pipeline.

  • On your repository page, click the green Code button.
  • Make sure the HTTPS tab is selected.
  • Click the copy icon to copy the repository URL.
  • Open Terminal by pressing Cmd+Space (macOS) and typing Terminal, then press Enter.
  • Move to your Desktop by running this command:
cd ~/Desktop
  • Clone your repository by running this command:
git clone [[REPO_URL="https://github.com/YOUR-USERNAME/my-first-pipeline.git"]]

What does git clone do?

The git clone command downloads your entire repository from GitHub to your Mac. It creates a folder with the same name as your repository and sets up the connection back to GitHub so you can push changes later.

  • Confirm the repository was cloned by running:
ls

You should see my-first-pipeline listed in the output.

  • Move into the project folder by running:
cd my-first-pipeline
  • Open the project in VS Code by running:
code .

VS Code opens with your my-first-pipeline folder loaded. You should see README.md in the Explorer sidebar on the left.

Getting "command not found: code"?

The code command needs to be installed from inside VS Code. Open VS Code manually, press Cmd+Shift+P, type Shell Command: Install, and select the option. Then close and reopen Terminal and try again.

Help me open my project in VS Code from Terminal.

GitHub asked for a password when cloning?

If GitHub prompts you for credentials, it may open a browser window to authenticate. Follow the prompts to sign in. If you see a username/password prompt in Terminal instead, make sure you copied the HTTPS URL (not SSH) from the green Code button on your repository page.

Help me authenticate with GitHub to clone my repository.

Your repository is set up and connected. Next up, you will build a Node.js project with tests inside this folder.

Build a Simple Node.js Project

Your repository is cloned and open in VS Code. Now it's time to write some actual code.

Every CI/CD pipeline needs code to validate. In this step, you'll build a small calculator module and write automated tests that your pipeline will eventually run on every push.

In this step, get ready to:
  • Initialize a Node.js project with npm.
  • Create a calculator module with three functions.
  • Write automated tests and run them locally.
Initialize the project and create the calculator module

Node.js projects use a package.json file to track metadata, scripts, and dependencies. The npm init command generates this file automatically.

  • Open VS Code's built-in terminal by pressing Ctrl+` (backtick key, top-left of your keyboard).
  • Initialize your Node.js project by running this command:
npm init -y

What does this command do?

npm init creates a package.json file in your project folder. The -y flag accepts all default values so you skip the interactive prompts.

  • You should see package.json appear in the Explorer sidebar on the left of VS Code.

Don't see package.json?

Make sure your terminal is inside the my-first-pipeline folder. Run pwd to check your current directory. If it shows a different folder, run cd ~/Desktop/my-first-pipeline to navigate there.

My npm init command isn't working. How do I fix this?

  • Create the src folder for your application code by running:
mkdir src
  • Confirm the folder was created by running:
ls
  • You should see src listed alongside package.json and README.md.
  • In VS Code's Explorer sidebar, right-click on the src folder.
  • Click New File.
  • Name the file calculator.js and press Enter.
  • Paste the following code into calculator.js:
// Add two numbers together
function add(a, b) {
  return a + b;
}

// Subtract the second number from the first
function subtract(a, b) {
  return a - b;
}

// Multiply two numbers together
function multiply(a, b) {
  return a * b;
}

// Export all functions so other files can use them
module.exports = { add, subtract, multiply };

What does this code do?

  • add, subtract, and multiply are simple functions that take two numbers and return a result.
  • module.exports makes these functions available to other files. Your test file will import them using this export.
  • Save calculator.js by pressing Cmd+S (macOS) or Ctrl+S (Windows).

Seeing a red underline in VS Code?

Check that all function names are spelled correctly and each function has matching curly braces {}. Make sure the last line uses curly braces in module.exports = { add, subtract, multiply }, not parentheses.

I'm seeing an error in my calculator.js file. Can you help me debug it?

✔️ Awesome, I've got everything!

Great. Double check you've saved your file before moving on.

ⓧ I'd like to double check the full code

// Add two numbers together
function add(a, b) {
  return a + b;
}

// Subtract the second number from the first
function subtract(a, b) {
  return a - b;
}

// Multiply two numbers together
function multiply(a, b) {
  return a * b;
}

// Export all functions so other files can use them
module.exports = { add, subtract, multiply };
Create the test file

Now that you have functions to test, you'll write automated tests using Node.js's built-in test runner. This test runner is included with Node.js so you don't need to install anything extra.

  • Create the tests folder by running this command in your terminal:
mkdir tests
  • Confirm the folder was created by running:
ls
  • You should see tests listed alongside src, package.json, and README.md.
  • In VS Code's Explorer sidebar, right-click on the tests folder.
  • Click New File.
  • Name the file calculator.test.js and press Enter.
  • Paste the following code into calculator.test.js:
const { describe, it } = require('node:test');
const assert = require('node:assert');
const { add, subtract, multiply } = require('../src/calculator');

describe('Calculator', () => {
  // Test the add function with positive and negative numbers
  it('should add two numbers', () => {
    assert.strictEqual(add(2, 3), 5);
    assert.strictEqual(add(-1, 1), 0);
  });

  // Test the subtract function
  it('should subtract two numbers', () => {
    assert.strictEqual(subtract(5, 3), 2);
    assert.strictEqual(subtract(0, 5), -5);
  });

  // Test the multiply function including edge case with zero
  it('should multiply two numbers', () => {
    assert.strictEqual(multiply(3, 4), 12);
    assert.strictEqual(multiply(0, 100), 0);
  });
});

What does this code do?

  • require('node:test') imports the built-in test runner. require('node:assert') imports the assertion library for checking values.
  • describe('Calculator', ...) groups related tests under one label.
  • Each it() block tests one function. assert.strictEqual() compares the actual result to the expected value. If they don't match, the test fails.
  • The path '../src/calculator' tells Node.js to go up one directory from tests/ into the project root, then into src/.
  • Save calculator.test.js by pressing Cmd+S (macOS) or Ctrl+S (Windows).

Seeing red underlines in the test file?

Check that the require path '../src/calculator' has two dots at the start. This relative path is how Node.js finds your calculator module from the tests/ folder.

Make sure the function names in your require statement (add, subtract, multiply) match the names in calculator.js exactly.

I'm seeing errors in my test file. Can you help me fix them?

✔️ Awesome, I've got everything!

Great. Double check you've saved your file before moving on.

ⓧ I'd like to double check the full code

const { describe, it } = require('node:test');
const assert = require('node:assert');
const { add, subtract, multiply } = require('../src/calculator');

describe('Calculator', () => {
  // Test the add function with positive and negative numbers
  it('should add two numbers', () => {
    assert.strictEqual(add(2, 3), 5);
    assert.strictEqual(add(-1, 1), 0);
  });

  // Test the subtract function
  it('should subtract two numbers', () => {
    assert.strictEqual(subtract(5, 3), 2);
    assert.strictEqual(subtract(0, 5), -5);
  });

  // Test the multiply function including edge case with zero
  it('should multiply two numbers', () => {
    assert.strictEqual(multiply(3, 4), 12);
    assert.strictEqual(multiply(0, 100), 0);
  });
});
Add the test script and run your tests

Your tests exist, but Node.js doesn't know how to find and run them yet. You need to configure package.json with a test script that points to your test files.

  • In VS Code's Explorer sidebar, click on package.json to open it.
  • Select all the content in the file (Cmd+A on macOS or Ctrl+A on Windows).
  • Replace it with the following code:
{
  "name": "my-first-pipeline",
  "version": "1.0.0",
  "description": "My first CI/CD pipeline with GitHub Actions",
  "main": "src/calculator.js",
  "scripts": {
    "test": "node --test tests/"
  },
  "keywords": ["devops", "ci-cd", "github-actions"],
  "author": "",
  "license": "MIT"
}

What does this configuration do?

  • "test": "node --test tests/" tells npm to use Node.js's built-in test runner and look for test files in the tests/ folder.
  • "main": "src/calculator.js" declares the entry point of your project.
  • "description" and "keywords" are metadata that describe your project to other developers.
  • Save package.json by pressing Cmd+S (macOS) or Ctrl+S (Windows).
  • Run your tests by entering this command in the terminal:
npm test

You should see output listing each test with a pass indicator. All three tests (add, subtract, multiply) should pass successfully.

What should I see?

The terminal output shows each test case name followed by a pass status. Look for lines mentioning should add two numbers, should subtract two numbers, and should multiply two numbers all passing.

You should also see a summary like tests 3 and pass 3 at the bottom.

Tests failing?

Check that you saved both calculator.js and calculator.test.js before running npm test.

Make sure the file path in your test file reads '../src/calculator' with no file extension. Verify that package.json has the correct test script: "test": "node --test tests/".

My npm test command is failing. How do I fix this?

✔️ Awesome, I've got everything!

Great. Double check you've saved all your files before moving on.

ⓧ I'd like to double check the full code

{
  "name": "my-first-pipeline",
  "version": "1.0.0",
  "description": "My first CI/CD pipeline with GitHub Actions",
  "main": "src/calculator.js",
  "scripts": {
    "test": "node --test tests/"
  },
  "keywords": ["devops", "ci-cd", "github-actions"],
  "author": "",
  "license": "MIT"
}

Your code and tests are working locally. Next up, you'll create a GitHub Actions workflow that runs these tests automatically every time you push code.

Create Your GitHub Actions Workflow

Your tests pass locally, which is great. But what happens when you push code without remembering to run them first? Right now, nobody is checking automatically.

GitHub Actions lets you define automated workflows in a YAML file. In this step, you'll create one that runs your tests on every push to GitHub.

In this step, get ready to:
  • Create the .github/workflows/ directory structure.
  • Write a ci.yml workflow that triggers on every push.
  • Commit and push everything to GitHub.
Create the workflow directory

GitHub Actions looks for workflow files in a specific location: the .github/workflows/ folder inside your repository. Without this exact folder structure, GitHub won't detect your workflow.

  • In VS Code, open the integrated terminal by pressing Cmd+` (macOS) or Ctrl+` (Windows).
  • Make sure you're inside your my-first-pipeline folder (you should see it in your terminal prompt).
  • Create the workflow directory by running this command:
mkdir -p .github/workflows
  • Confirm the directory was created by running:
ls -a .github

You should see workflows listed in the output.

Why is the folder name .github?

Folders starting with a dot are hidden by default on macOS and Linux. GitHub uses this .github directory as a special configuration folder for your repository.

The -p flag in mkdir creates parent directories as needed, so both .github and workflows are created in one command.

Don't see the workflows folder?

Make sure you ran the command from inside your my-first-pipeline folder, not from your Desktop or home directory. Run pwd to check your current location.

Help me find my .github/workflows directory

Write the CI workflow file

A workflow file defines what GitHub should do when certain events happen. You'll tell it: when code is pushed, spin up a virtual machine, install Node.js, and run the tests.

  • Create a new file called ci.yml inside the .github/workflows/ folder.
  • In the VS Code Explorer sidebar, right-click the workflows folder and select New File.
  • Name the file ci.yml and press Enter.
  • Paste the following workflow into the file:
name: CI Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v6
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '24'
      - run: npm ci
      - run: npm test

What does this workflow do?

  • name: CI Pipeline gives your workflow a human-readable name that shows up in the GitHub Actions tab.
  • on: push / pull_request tells GitHub to run this workflow whenever code is pushed or a pull request is opened against the main branch.
  • runs-on: ubuntu-latest spins up a fresh Linux virtual machine (hosted free by GitHub) to run your pipeline.
  • actions/checkout@v6 downloads your repository code onto that virtual machine.
  • actions/setup-node@v4 installs Node.js 24 on the runner so it can execute your JavaScript.
  • npm ci installs your project dependencies from the lock file (faster and more reliable than npm install for CI environments).
  • npm test runs your test suite. If any test fails, the whole pipeline fails.
  • Save ci.yml by pressing Cmd+S (macOS) or Ctrl+S (Windows).

In the VS Code Explorer sidebar, you should now see the folder structure: .github > workflows > ci.yml.

Don't see .github in the sidebar?

Hidden folders (starting with a dot) sometimes don't appear immediately in VS Code's Explorer. Click the refresh icon at the top of the Explorer panel, or close and reopen the folder.

Also check that you created the directory from inside my-first-pipeline and not a parent folder.

Help me find my ci.yml file in VS Code

✔️ Awesome, I've got everything!

Great. Make sure you've saved the file before moving on to the next substep.

ⓧ I'd like to double check the full code

Here's the complete workflow file. Make sure yours matches exactly, including the indentation.

name: CI Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v6
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '24'
      - run: npm ci
      - run: npm test
Commit and push to GitHub

Your workflow file only takes effect once it reaches GitHub. You need to commit it to your local Git repository and then push it to the remote.

Before committing, you need to generate a package-lock.json file. The npm ci command in your workflow requires it.

  • Generate the lock file by running this command:
npm install

Why do I need a lock file?

The npm ci command reads from package-lock.json to install the exact versions of every dependency. This makes your CI builds faster and more predictable than using npm install.

  • Stage all your files, commit them, and push to GitHub by running these commands:
git add .
git commit -m "Add CI workflow and project files"
git push

What do these commands do?

  • git add . stages every new and changed file in your project for the next commit.
  • git commit -m "..." saves a snapshot of those changes with a message describing what you did.
  • git push uploads your local commits to the remote repository on GitHub.
  • Open your browser and go to your my-first-pipeline repository on GitHub.
  • Refresh the page.

You should see all your project files listed: .github/workflows/ci.yml, src/calculator.js, tests/calculator.test.js, package.json, and package-lock.json.

Push rejected or authentication error?

If you see a message about authentication failing, GitHub may need you to sign in through the browser. When prompted, follow the browser-based login flow and try git push again.

If you see "Updates were rejected because the remote contains work that you do not have locally," run git pull --rebase first, then try git push again.

Help me push my code to GitHub

Your workflow file is live on GitHub. Next up, you'll head to the Actions tab and watch your pipeline run in real-time.

Watch Your Pipeline Run (and Fail)

Your workflow file is live on GitHub, and the push you made in the last step already triggered your pipeline.

In this step, you will watch the pipeline run in real-time on GitHub Actions. You will also intentionally break your code to prove that the automation catches bugs before they reach production.

In this step, get ready to:
  • Watch your pipeline pass with a green checkmark.
  • Intentionally break a test and see the pipeline fail.
  • Fix the test and confirm the pipeline recovers.
See your pipeline pass

When you pushed your code in the last step, GitHub detected the ci.yml workflow file and automatically started running it. Your pipeline is already running (or has already finished) on GitHub's servers.

  • Open your browser and go to your my-first-pipeline repository on GitHub.
  • Click the Actions tab at the top of the repository page.

You should see a workflow run listed with a green checkmark. The run was triggered by your most recent push to main.

  • Click on the workflow run (it will be named after your commit message) to see its details.
  • Click the test job to expand its steps.

You should see each step (checkout, setup Node.js, npm ci, npm test) completed with green checkmarks.

What just happened?

GitHub spun up a fresh ubuntu-latest virtual machine (called a runner), cloned your code into it, installed Node.js, ran npm ci to install dependencies, and then ran npm test. All of this happened automatically, without you clicking a thing.

This is Continuous Integration in action. Every push triggers a fresh validation of your code.

Don't see a green checkmark?

If you see a yellow dot, the pipeline is still running. Wait a minute and refresh the page.

If you see a red X, click into the failed step to read the error message. Common causes: a typo in ci.yml (YAML is sensitive to indentation), or a missing package-lock.json file (required by npm ci).

Help me figure out why my GitHub Actions pipeline failed

Break a test intentionally

A pipeline that only passes does not prove much. You need to see it fail to trust that it actually catches problems.

  • In VS Code, open tests/calculator.test.js.
  • Find this line inside the first test:
assert.strictEqual(add(2, 3), 5);
  • Change 5 to 99, so the line now looks like this:
assert.strictEqual(add(2, 3), 99);

Why 99?

You are telling the test to expect that 2 + 3 equals 99. This is obviously wrong, so the test will fail. This simulates what happens when a real bug slips into your code.

  • Save tests/calculator.test.js.
  • Commit and push the broken test to GitHub by running these commands in your terminal:
git add .
git commit -m "Break test to see pipeline fail"
git push
  • Go back to the Actions tab on your GitHub repository.
  • Wait for the new workflow run to appear (it triggers automatically on push).

After a minute or so, you should see a red X next to this run. Click into it to see the failure details.

  • Click the failed test job to expand its steps.
  • Click the failed Run npm test step to see the error output.

You should see an assertion error message showing that the test expected 99 but received 5. Your pipeline caught the bug.

Pipeline not appearing?

Make sure your git push command completed without errors. If you see a permission error, confirm you are authenticated to GitHub (run git remote -v to check your remote URL).

Help me troubleshoot why my push to GitHub is not triggering a new pipeline run

Fix the test and watch the pipeline recover

You have proven the pipeline catches failures. Now close the loop by fixing the bug and confirming the pipeline goes green again.

  • In VS Code, open tests/calculator.test.js again.
  • Find the line you changed:
assert.strictEqual(add(2, 3), 99);
  • Change 99 back to 5, so the line reads:
assert.strictEqual(add(2, 3), 5);
  • Save tests/calculator.test.js.
  • Commit and push the fix by running these commands:
git add .
git commit -m "Fix broken test"
git push
  • Go back to the Actions tab on GitHub.
  • Wait for the new run to complete.

You should see a green checkmark again. Your pipeline is back to a healthy state.

What is the CI feedback loop?

You just experienced the core DevOps feedback loop: push code, pipeline validates, you see the result. If something breaks, you fix it and push again.

In a real team, this loop runs on every pull request. No broken code gets merged into main because the pipeline blocks it first.

Still seeing a red X after the fix?

Make sure you changed 99 back to 5 (not to a different wrong value). Run npm test locally to confirm your tests pass before pushing.

Help me figure out why my pipeline is still failing after I fixed my test

Secret mission

Add Automated Linting

Your pipeline catches broken tests. But what about messy code? Add ESLint to your workflow so the pipeline also enforces code style automatically. No more sloppy variables slipping through to production.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally and uses a free public GitHub repository. There are no ongoing costs to worry about.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • GitHub repository (my-first-pipeline).
  • Local project folder (my-first-pipeline on your Desktop).
  • Node.js installation.
  • Git installation (via Xcode Command Line Tools).
  • VS Code installation.
  • GitHub account.

Keep everything running

No action needed. Choose this if you're still actively building or plan to extend the project with the Secret Mission.

  • Your GitHub repository stays public and the Actions workflow continues to run on every push at no cost.
  • Your local project folder remains on your Desktop.
  • Node.js, Git, and VS Code stay installed for future projects.

Pause - I'll come back to this later

Shut down running processes to free up memory. Your files and repository stay intact for when you return.

  • Close VS Code.
  • Close your Terminal window.
  • Your GitHub repository and local files remain exactly as you left them. No data is lost.

Delete - I don't want to use this again

Remove all project resources and start fresh. This cannot be undone.

  • Delete the local project folder by opening Terminal and running:
rm -rf ~/Desktop/my-first-pipeline
  • Delete the GitHub repository by going to your repository page, clicking Settings, scrolling to the bottom, and clicking Delete this repository.
  • Node.js, Git, and VS Code can stay installed. They are useful for future projects and take minimal disk space.

That's a Wrap!

That's a Wrap!

Nice work! You just built a fully automated CI/CD pipeline that tests your code every time you push to GitHub.

You've learned how to:

  • Build a Node.js project with automated tests using the built-in test runner.
  • Create a GitHub Actions workflow that triggers on every push to validate your code.
  • Watch your pipeline catch a broken test automatically, proving the core CI/CD feedback loop works.
  • Added automated linting to your pipeline to enforce code quality on every push.

Ready to quiz yourself?