Build a CI/CD Pipeline with Azure DevOps

Set up an automated CI/CD pipeline in Azure DevOps from scratch.

Introduction

30 Second Summary

Professional software teams ship code multiple times a day without breaking things. The secret is automation that catches bugs before they ever reach users.

In this project, you will build a CI/CD pipeline in Azure DevOps that automatically builds and tests your code every time you push a change. You will also track your work on a Kanban board, giving you hands-on experience with the same tools used by enterprise development teams.

What You'll Build

A complete Azure DevOps project with a Kanban board for tracking work, a Git repository for your code, and a YAML pipeline that automatically builds and tests a Node.js app on every commit.

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

  • An Azure DevOps organization and project with a Kanban board tracking your pipeline setup.
  • A Git repository in Azure Repos containing a Node.js app with automated tests.
  • A YAML-based CI pipeline that installs dependencies, runs tests, and displays a build status badge.
  • Secret Mission: Add a multi-stage pipeline that packages your app into a deployable artifact.

Are there any prerequisites?

You need basic familiarity with Git (commit, push, pull). No prior Azure or DevOps experience is required. Everything else is covered step by step.

Before We Start

Before We Start...

Set Up Your Azure DevOps Account

Azure DevOps is Microsoft's all-in-one platform for planning, building, and shipping software. It bundles project boards, Git repositories, and automated pipelines into a single service.

In this step, you'll create a free Azure DevOps account, set up your first project, and confirm that Git is ready on your local machine.

In this step, get ready to:
  • Create an Azure DevOps organization.
  • Create a project for your pipeline.
  • Verify Git is installed on your local machine.
Create your Azure DevOps organization

An organization in Azure DevOps is the top-level container for all your projects, repositories, and pipelines. You'll create one for free at dev.azure.com.

  • Open your browser and navigate to dev.azure.com.
  • Click Start free.
  • Sign in with your Microsoft account. If you don't have one, select the option to create a new Microsoft account and follow the prompts.
  • Review and agree to the Terms of Service.
  • Enter a unique name for your organization. This becomes part of your URL (e.g. https://dev.azure.com/your-org-name).
  • Choose a hosting location closest to you from the dropdown.
  • Complete the captcha verification and click Continue.

What is an Azure DevOps organization?

An organization groups all of your projects under one roof. Think of it like a company account that can hold multiple projects, each with its own repos, boards, and pipelines.

You can access your organization at any time by visiting https://dev.azure.com/{Your_Organization}.

Stuck on the sign-up page?

If the page doesn't respond after clicking Continue, try opening an Incognito or InPrivate browser window and disabling any ad-blockers or script-blocking extensions. Make sure third-party cookies and JavaScript are allowed for dev.azure.com.

Help me troubleshoot my Azure DevOps sign-up

Create a new project

After creating your organization, Azure DevOps prompts you to create your first project. A project is where your code, pipeline, and board live together.

  • Enter my-first-pipeline in the Project name field.
  • Set Visibility to Public.
  • Under Advanced, select Git for version control.
  • Select Basic for the work item process.
  • Click Create.

Azure DevOps displays your new project's welcome page with links to Boards, Repos, and Pipelines.

Why Public visibility?

New Azure DevOps organizations do not receive free Microsoft-hosted pipeline minutes by default for private projects. You must submit a request that can take several business days to process.

Setting your project to Public gives you 10 free parallel jobs with up to 360 minutes each. This lets you run pipelines immediately without waiting for approval.

Verify Git is installed

You'll use Git to push code to your Azure Repos repository in later steps. Let's confirm it's available on your machine.

  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Terminal (macOS) or Command Prompt (Windows) and press Enter to open it.
  • Check your Git installation by running this command:
git --version

✔️ I see a version number

If your terminal prints something like git version 2.x.x, Git is installed and ready to go. You're all set for the next step.

ⓧ Command not found

If your terminal says the command was not found, you need to install Git.

macOS

  • Install Git by running this command in your terminal:
xcode-select --install
  • A dialog box appears asking you to install the command line developer tools. Click Install and wait for the download to finish.
  • After installation completes, run git --version again to confirm it works.

Windows

  • Open your browser and go to https://git-scm.com/download/win. The download starts automatically.
  • Run the downloaded installer and accept all the default settings by clicking Next through each screen.
  • After installation completes, close and reopen Command Prompt.
  • Run git --version again to confirm it works.

Git still not recognized after installing?

Make sure you closed and reopened your terminal after installation. New programs are only available in fresh terminal sessions. On Windows, if you used the Git for Windows installer, try opening Git Bash instead of Command Prompt.

Help me get Git working on my machine

Your Azure DevOps environment is ready and Git is confirmed on your machine. Next up, you'll plan your work using Azure Boards before building the pipeline.

Plan Your Work with Azure Boards

Before you write any code, professional teams plan their work. This makes it easy to track progress and know what's done at a glance.

In this step, you'll use Azure Boards to create work items and organize them on a Kanban board. Each card on the board represents a task, and you'll drag cards between columns as you complete work throughout the project.

In this step, get ready to:
  • Create three work items on your board.
  • Move a work item to the Doing column.
Create work items on your board

Your project uses the Basic process, which tracks work using Issues. The board has three columns: To Do, Doing, and Done. You'll create one Issue for each major task in this project.

  • In the left sidebar of your Azure DevOps project, click Boards.
  • Click Boards again in the submenu that appears.
  • You should see an empty board with three columns: To Do, Doing, and Done.

What is a Kanban board?

A Kanban board is a visual tool that shows work as cards moving through columns. Each column represents a stage of work. As you complete tasks, you drag them from left to right across the board.

In the Basic process, Issues flow from To Do to Doing to Done.

  • In the To Do column, click New item.
  • Type Set up repository and press Enter.
  • Click New item again, type Create CI pipeline, and press Enter.
  • Click New item one more time, type Add test stage, and press Enter.

You should now see three cards in the To Do column of your board.

Don't see the New item button?

Make sure you're on the Boards view (not Backlogs or Sprints). The board selector at the top should say Issues. If it shows something else, click the dropdown and select Issues.

help me find the New item button on my Azure Boards Kanban board

Move your first work item to Doing

You're about to start setting up a repository in the next step. Let's update the board to reflect that.

  • Click and drag the Set up repository card from the To Do column to the Doing column.
  • Release the card once it's in the Doing column.

Your board now shows one item in Doing and two items still in To Do. You'll move these cards as you complete each task throughout the project.

Why track work on a board?

In real teams, boards give everyone visibility into what's in progress and what's blocked. Even on a solo project, moving cards across the board builds the habit of tracking work the way professional teams do.

Your board is set up and ready to track progress. Next, you'll set up your code repository and push your first application.

Set Up Your Repository and App

Your board is ready and your first work item is in progress. Now it's time to write some actual code.

In this step, you'll clone the empty Azure Repos repository to your local machine, create a simple Node.js application, and push it to the cloud. This gives your pipeline something to build and test in the next step.

In this step, get ready to:
  • Clone your Azure Repos repository locally.
  • Create a Node.js app with a server and a test file.
  • Push your code and update your board.
Clone your repository locally
  • In your Azure DevOps project, click Repos in the left sidebar.
  • Click Files.
  • Click the Clone button in the upper-right corner of the page.
  • Copy the HTTPS clone URL displayed in the popup.

What is the clone URL?

The clone URL is your repository's address on Azure DevOps. It follows a format like https://dev.azure.com/{org}/my-first-pipeline/_git/my-first-pipeline. You'll paste this into your terminal to download a local copy of the repository.

  • Open your terminal by pressing Cmd+Space (macOS) or the Windows key (Windows) and typing Terminal.
  • Move to your Desktop by running this command:
cd ~/Desktop
  • Clone the repository by running this command, replacing the URL with the one you copied:
git clone [[CLONE_URL="your HTTPS clone URL from Azure DevOps"]]

What does this command do?

The git clone command downloads a complete copy of the remote repository to your machine. Since the repo is empty, it creates a folder with just the hidden .git directory that tracks changes.

You may see a warning that you cloned an empty repository. That's expected.

  • Move into the cloned folder by running:
cd my-first-pipeline
  • Open the my-first-pipeline folder in your code editor.

Clone failing or asking for credentials?

If Git asks for a username and password, enter your Azure DevOps email and a Personal Access Token (PAT) as the password. You can generate a PAT from your Azure DevOps user settings under Personal access tokens.

Help me troubleshoot cloning my Azure Repos repository.

Create the Node.js app files

Your repository needs three files: a package manifest, a web server, and a test. The app itself is intentionally simple so you can focus on the pipeline.

  • Create package.json in your code editor with the following content:
{
  "name": "my-first-pipeline",
  "version": "1.0.0",
  "description": "A simple Node.js app for learning Azure DevOps pipelines",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "node --test"
  },
  "keywords": [],
  "author": "",
  "license": "MIT"
}

What does this file do?

The package.json file describes your Node.js project. The scripts section is key here.

The test script runs node --test, which is Node.js's built-in test runner. Your pipeline will call this later to verify your code works.

  • Save package.json.

✔️ Awesome, I've got everything!

Great. Move on to creating the next file.

ⓧ I'd like to double check the full code

{
  "name": "my-first-pipeline",
  "version": "1.0.0",
  "description": "A simple Node.js app for learning Azure DevOps pipelines",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "node --test"
  },
  "keywords": [],
  "author": "",
  "license": "MIT"
}
  • Create index.js in your code editor with the following content:
// Import Node.js built-in HTTP module
const http = require("http");

// Use the PORT environment variable or default to 3000
const port = process.env.PORT || 3000;

// Create an HTTP server that responds with a greeting
const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello from Azure DevOps!\n");
});

// Start the server and log the port
server.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

// Export the server so the test file can use it
module.exports = server;

What does this code do?

This creates a minimal web server using Node.js's built-in http module. When someone visits the server, it responds with "Hello from Azure DevOps!" and a 200 status code.

The module.exports = server line makes the server accessible to other files. Your test file will import it to verify the response.

  • Save index.js.

✔️ Awesome, I've got everything!

Great. One more file to go.

ⓧ I'd like to double check the full code

const http = require("http");

const port = process.env.PORT || 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello from Azure DevOps!\n");
});

server.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

module.exports = server;
  • Create test.js in your code editor with the following content:
// Import the built-in test runner and assertion library
const { test } = require("node:test");
const assert = require("node:assert");
const http = require("http");

// Import the server from index.js
const server = require("./index.js");

// Test that the server responds with a 200 status and the expected greeting
test("server responds with 200 and greeting", (t, done) => {
  const req = http.get("http://localhost:3000", (res) => {
    assert.strictEqual(res.statusCode, 200);
    let data = "";
    res.on("data", (chunk) => {
      data += chunk;
    });
    res.on("end", () => {
      assert.strictEqual(data, "Hello from Azure DevOps!\n");
      server.close();
      done();
    });
  });
  req.on("error", (err) => {
    server.close();
    done(err);
  });
});

What does this test do?

This test starts the server (by importing it), sends an HTTP request to localhost:3000, and checks two things: that the response status code is 200, and that the body matches "Hello from Azure DevOps!".

It uses Node.js's built-in test runner (node:test), so you don't need to install any extra testing packages. This test runner requires Node.js 18 or higher.

  • Save test.js.
  • Confirm the files exist by running:
ls

You should see index.js, package.json, and test.js listed in the output.

✔️ Awesome, I've got everything!

Great. Make sure all three files are saved before pushing.

ⓧ I'd like to double check the full code

{
  "name": "my-first-pipeline",
  "version": "1.0.0",
  "description": "A simple Node.js app for learning Azure DevOps pipelines",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "node --test"
  },
  "keywords": [],
  "author": "",
  "license": "MIT"
}
const http = require("http");

const port = process.env.PORT || 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello from Azure DevOps!\n");
});

server.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

module.exports = server;
const { test } = require("node:test");
const assert = require("node:assert");
const http = require("http");
const server = require("./index.js");

test("server responds with 200 and greeting", (t, done) => {
  const req = http.get("http://localhost:3000", (res) => {
    assert.strictEqual(res.statusCode, 200);
    let data = "";
    res.on("data", (chunk) => {
      data += chunk;
    });
    res.on("end", () => {
      assert.strictEqual(data, "Hello from Azure DevOps!\n");
      server.close();
      done();
    });
  });
  req.on("error", (err) => {
    server.close();
    done(err);
  });
});

Missing a file?

Make sure you created each file in the my-first-pipeline folder (the one you cloned), not in a parent or subfolder. Each file should be at the top level of the repository.

Help me find my missing files.

Push your code to Azure Repos

Your files are saved locally, but your Azure DevOps repository is still empty. Pushing sends your code to the cloud so the pipeline can access it.

  • Stage, commit, and push all your files by running these commands:
git add .
git commit -m "Add Node.js app with tests"
git push

What do these commands do?

  • git add . stages all new and modified files for the next commit.
  • git commit -m "Add Node.js app with tests" saves a snapshot of your staged files with a descriptive message.
  • git push uploads your commit to the remote repository on Azure DevOps.
  • Return to your Azure DevOps project in the browser.
  • Click Repos then Files in the left sidebar.

You should see index.js, package.json, and test.js listed in your repository.

Push rejected or files not appearing?

If you see an error about the remote being ahead, try running git pull --rebase then git push again. This happens when Azure DevOps initialized the repo with a README or .gitignore.

Help me fix my git push to Azure Repos.

Update your board
  • Click Boards in the left sidebar of your Azure DevOps project.
  • Drag the Set up repository card from Doing to the Done column.
  • Drag the Create CI pipeline card from To Do to the Doing column.

Your board now reflects your progress. The repository task is complete and the pipeline task is next.

Why track work items?

Moving cards across columns is how real development teams visualize their workflow. It helps everyone see what's in progress, what's blocked, and what's done. This is a core practice in Kanban-based project management.

Your app is in the cloud and your board is up to date. Next up, you'll create a YAML pipeline that automatically builds and tests this code every time you push a change.

Create Your First YAML Pipeline

Your repository has code and a passing test. Now it's time to automate everything with a pipeline that builds and tests your app on every single commit.

Azure Pipelines uses a YAML file to define exactly what happens when code is pushed. You'll write this file step by step, telling Azure which machine to use, which tools to install, and which commands to run.

In this step, get ready to:
  • Navigate to Azure Pipelines and start a new pipeline.
  • Write a YAML pipeline that installs dependencies and runs tests.
  • Trigger your first automated build and watch it pass.
Navigate to Pipelines and create a starter pipeline

Azure DevOps has a guided wizard that walks you through connecting a pipeline to your repository. You'll use it to generate a starter YAML file that you can customize.

  • In your Azure DevOps project, click Pipelines in the left sidebar.
  • Click Create Pipeline.
  • On the Connect screen, select Azure Repos Git as your code source.
  • Select your repository (my-first-pipeline).
  • On the Configure your pipeline screen, select Starter pipeline.

You should now see the Azure DevOps YAML editor with a pre-filled starter template. You'll replace this entire template in the next substep.

What is a YAML pipeline?

A YAML pipeline is a text file that lives in your repository alongside your code. It tells Azure Pipelines exactly what to do on every commit: which virtual machine to spin up, which tools to install, and which commands to run.

Because it's a file in your repo, your pipeline definition is version-controlled just like your application code. You can review changes, revert mistakes, and see the full history.

Replace the starter YAML with your pipeline

The starter template is generic. You'll replace it with a pipeline tailored to your Node.js app that installs dependencies and runs your test.

  • Select all the existing code in the YAML editor and delete it.
  • Paste the following YAML into the editor:
trigger:
  - main

pool:
  vmImage: "ubuntu-latest"

steps:
  - task: NodeTool@0
    inputs:
      versionSpec: "20.x"
    displayName: "Install Node.js 20.x"

  - script: npm install
    displayName: "Install dependencies"

  - script: npm test
    displayName: "Run tests"

What does this YAML do?

  • trigger: - main tells Azure Pipelines to run this pipeline whenever code is pushed to the main branch.
  • vmImage: "ubuntu-latest" spins up a fresh Ubuntu virtual machine (a Microsoft-hosted build agent) to run your pipeline.
  • NodeTool@0 installs Node.js 20.x on the build agent so your app can run.
  • The two script steps run npm install and npm test just like you would locally.

✔️ Awesome, I've got everything!

Great. Double check your YAML matches the code above exactly, especially the indentation. YAML is sensitive to spacing.

ⓧ I'd like to double check the full code

Here is the complete azure-pipelines.yml file:

trigger:
  - main

pool:
  vmImage: "ubuntu-latest"

steps:
  - task: NodeTool@0
    inputs:
      versionSpec: "20.x"
    displayName: "Install Node.js 20.x"

  - script: npm install
    displayName: "Install dependencies"

  - script: npm test
    displayName: "Run tests"
Save and run your first build

Clicking Save and run does two things at once: it commits the azure-pipelines.yml file to your repository and immediately triggers your first pipeline run.

  • Click Save and run in the top right corner of the YAML editor.
  • In the dialog that appears, leave the default commit message and branch (main).
  • Click Save and run again to confirm.

Azure DevOps redirects you to the pipeline run page. You can watch each step execute in real time.

  • Wait for the pipeline to finish. You should see a green checkmark and all three steps (Install Node.js, Install dependencies, Run tests) showing as succeeded.

What just happened?

Azure Pipelines detected the new commit on main, spun up a fresh Ubuntu VM, installed Node.js 20.x, ran npm install, and executed your test. All of this happened automatically without you running a single command.

This is Continuous Integration in action. Every future commit to main will trigger the same process.

Pipeline stuck or showing an error?

  • If you see an indentation error, go back and check that every line in your YAML uses exactly 2 spaces for indentation (not tabs). YAML is whitespace-sensitive.
  • If the test step fails, make sure your test.js and package.json files were pushed to the main branch in the previous step. The pipeline checks out whatever is on main.
  • If the pipeline is queued but not running, confirm your project is set to Public visibility. Private projects require a parallelism grant that can take several days to process.

Why is my Azure DevOps pipeline failing or stuck in the queue?

Your pipeline is live and running on every commit. Next up, you'll make a code change to see CI in action and add a status badge to your repository.

Trigger a CI Build and Add a Status Badge

Your pipeline runs perfectly when you manually trigger it. But the real power of CI is that it runs automatically every time you push code.

In this step, you will prove that your pipeline triggers on every commit. You will also add a status badge to your repository so anyone can see whether the build is passing at a glance.

In this step, get ready to:
  • Push a code change and watch the pipeline trigger automatically.
  • Add a status badge to a README file in your repository.
  • Update your board to reflect that the CI pipeline is complete.
Push a code change to trigger the pipeline

Your pipeline is configured to trigger on any commit to the main branch. To prove this works, you will make a small edit to your code, push it, and watch the pipeline start on its own.

  • Open index.js in your code editor.
  • Find the console.log line inside the server.listen callback.
  • Add a comment directly above it, such as // Log server start.
  • Save index.js.
  • Stage, commit, and push your change by running these commands in your terminal:
git add .
git commit -m "Add comment to index.js"
git push

What does this do?

These three commands stage all changed files, create a commit with a message, and push the commit to the remote main branch in Azure Repos.

Because your azure-pipelines.yml has trigger: - main, pushing to main automatically starts a new pipeline run.

  • Return to Azure DevOps in your browser.
  • Click Pipelines in the left sidebar.
  • Open your pipeline. You should see a new run that was triggered automatically by your push.
  • Wait for the run to complete. All steps should pass with a green checkmark.

What is Continuous Integration?

Continuous Integration means every code push is automatically built and tested. You never have to remember to run tests manually. The pipeline catches broken code the moment it enters the repository.

Don't see a new pipeline run?

Make sure your git push completed successfully. Check your terminal output for errors.

Confirm you pushed to the main branch. If you are on a different branch, the trigger will not fire.

Why isn't my Azure DevOps pipeline triggering after I push?

Add a status badge to your README

A status badge is a small image that shows whether your latest build passed or failed. Adding one to your README gives instant visibility into your project's health.

  • In Azure DevOps, navigate to Pipelines in the left sidebar.
  • Click on your pipeline name to open it.
  • Click the three-dot menu (More Actions) in the top right corner of the pipeline page.
  • Select Status badge.
  • In the dialog that appears, make sure the branch is set to main.
  • Copy the Sample Markdown text. Keep it in your clipboard for the next step.

What is a status badge?

A status badge is a dynamic image URL provided by Azure DevOps. It updates in real time. When your latest build passes, the badge shows green. When it fails, it shows red.

Adding one to your README means anyone visiting your repository can instantly see if the code is in a healthy state.

  • Create a new file called README.md in the root of your project folder (the same folder that contains index.js).
  • Add the following content to README.md, pasting your copied badge Markdown where indicated:
# My First Pipeline

A simple Node.js app with a CI pipeline in Azure DevOps.

[[STATUS_BADGE="paste your status badge Markdown here"]]

## Running locally

```bash
npm install
npm start
```

## Running tests

```bash
npm test
```

What does this file do?

The README.md file is the front page of your repository. Anyone who visits the repo sees this first.

The badge Markdown you pasted renders as a clickable image that links to your latest pipeline run. The "Running locally" and "Running tests" sections give quick-start instructions to anyone cloning your project.

  • Save README.md.
  • Commit and push your new README by running these commands:
git add README.md
git commit -m "Add README with status badge"
git push
  • Return to your repository in Azure DevOps. Click Repos in the left sidebar.
  • You should see your README.md rendered at the bottom of the page with the status badge showing a green "passing" indicator.

Badge not showing or showing as broken?

Make sure you pasted the full Markdown snippet from the Status badge dialog. It starts with [![Build Status] and includes both the image URL and the link URL.

If the badge shows "not found", confirm your project visibility is set to Public. Private projects require authentication to display badges externally.

Help me fix my Azure DevOps status badge that isn't rendering in my README.

Update your board

Your CI pipeline is fully operational. Time to update your Kanban board to reflect this milestone.

  • Click Boards in the left sidebar.
  • Find the "Create CI pipeline" work item in the Doing column.
  • Drag it to the Done column.

Why move work items as you go?

Keeping your board up to date is a core DevOps practice. It gives your team a single source of truth for what is in progress, what is blocked, and what is complete. Even on a solo project, this habit builds muscle memory for professional workflows.

✔️ Awesome, I've got everything!

Great. Confirm you have saved and pushed both index.js and README.md, and that your board shows "Create CI pipeline" in the Done column.

ⓧ I'd like to double check the full code

Here is what your README.md should look like (the badge URL will be unique to your organization):

# My First Pipeline

A simple Node.js app with a CI pipeline in Azure DevOps.

[![Build Status](https://dev.azure.com/{Your_Organization}/my-first-pipeline/_apis/build/status/{Your_Pipeline_Name}?branchName=main)](https://dev.azure.com/{Your_Organization}/my-first-pipeline/_build/latest?definitionId={Your_Definition_Id}&branchName=main)

## Running locally

```bash
npm install
npm start
```

## Running tests

```bash
npm test
```

Your index.js, package.json, test.js, and azure-pipelines.yml remain unchanged from the previous step.

You now have a fully automated CI pipeline that builds and tests your code on every push. Next up, you will take on a Secret Mission to add a second pipeline stage that packages your app into a deployable artifact.

Secret mission

Add a Build Artifact Stage

Your pipeline builds and tests your code, but what happens next? In a real deployment workflow, you'd package your app into a deployable artifact. Add a second stage to your pipeline that zips your application and publishes it for downstream deployment.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on the Azure DevOps free tier, so there are no ongoing costs. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • Azure DevOps organization and project (cloud resource on dev.azure.com).
  • Local cloned repository folder on your machine.
  • Microsoft account (used to sign in to Azure DevOps).

Keep everything running

No action needed. Choose this if you're still actively building or want to reference this project later.

  • Your Azure DevOps project uses the free tier. Pipelines only run when you push code, so there's no cost while idle.
  • Your local repository stays on disk. You can reopen it in your code editor anytime.

Pause - I'll come back to this later

Free up local disk space while keeping your cloud project intact. You can re-clone the repository any time you return.

  • Delete your local repository folder. On macOS or Linux, open your terminal and run the command below. On Windows, open PowerShell and use the Windows command.
  • Your Azure DevOps project stays live in the cloud at no cost. Pipelines remain idle until you push again.

macOS

rm -rf ~/Desktop/my-first-pipeline

Windows

Remove-Item -Recurse -Force ~\Desktop\my-first-pipeline

Delete - I don't want to use this again

Remove all project resources completely. This frees local disk space and removes your cloud project from Azure DevOps.

  • Delete your local repository folder.

macOS

rm -rf ~/Desktop/my-first-pipeline

Windows

Remove-Item -Recurse -Force ~\Desktop\my-first-pipeline
  • Delete your Azure DevOps project.
  • Sign in to your organization at dev.azure.com.
  • Select Organization settings in the bottom-left corner.
  • Select Projects in the left menu.
  • Check the box next to your project, then click Delete.
  • Type the project name to confirm, then click Delete again.

What about the organization?

Deleting the project removes all repos, pipelines, boards, and artifacts inside it. If you also want to delete the entire organization, go to Organization settings then Overview and select Delete. Enter the organization name to confirm.

Deleted organizations can be recovered within 28 days. After that, all data is permanently removed.

Nice Work!

Nice Work!

You just built a professional CI/CD workflow from the ground up using Azure DevOps. Every commit to your repository now triggers an automated build-and-test cycle, exactly like teams at enterprise companies do every day.

Here's what you accomplished:

  • Set up a complete Azure DevOps project with Azure Boards for tracking work items through a Kanban workflow and Azure Repos for version-controlled source code.
  • Wrote a YAML pipeline that automatically installs dependencies, runs tests, and reports results on every commit to the main branch.
  • Verified your pipeline with a live CI trigger and added a status badge to your README so anyone can see build health at a glance.
  • Added a multi-stage pipeline that packages your app into a publishable build artifact, ready for deployment.

Ready to quiz yourself?