Azure DevOps: 5 Core Services Explained with Examples

Azure Devops is not just a pipeline tool. It's a collection of services that help teams plan, develop, test and deliver software.

Many beginners start learning DevOps by just jumping directly into CICD pipelines. They create a pipeline, connect a repository, run a build and deploy an application.

But there's a problem with this approach..

Without understanding the bigger picture it's easy to learn individual tools  without understanding how they work together in a real-world software delivery process.

Let's simplify that..

What is Azure DevOps?

Azure DevOps is a Microsoft platform that provides services for managing the software development lifecycle, from planning work to delivering applications.

It helps developers, testers, DevOps engineers, and project managers collaborate using a coomon set of tools.

Consider a simple example:

Your team is building an online shopping application. You need too:

-> Plan a new feature, such as adding a shopping cart.
-> Store the application's source code.
-> Build and test the application automatically.
-> Manage packages and dependencies.
-> Deploy the application to a testing or production environment.

Azure DevOps provides services that support these activities.

Let's explore the five core services:

1. Azure Boards - Plan and Track Work
   

What problem does it solve?

Before writing code, a team needs to decide what to build, who will work on it, and what needs to be completed.

Azure Boards helps teams organize and track this work.

It supports work items such as Epics, Features, User Stories, Tasks, and Bugs, depending on the team's process.

Simple example:

Imagine you're developing an online shopping application.

The product owner requests a new feature: users should be able to add products to their shopping carts.

You can create a  User Story in Azure Boards:

User Story: As a customer, I want to add products to my shopping cart so that i can purchase multiple items together.

Then create tasks such as:

• Develop the Add to Cart API.
• Create the shopping cart interface.
• Write unit tests.
• Fix any identified bugs.

Each task can be assigned to a team member and tracked through its status.

For example:

New  -> Active -> Resolved -> Closed

The exact workflow depends on your team's process.

Why does it matter?

Azure Boards provide visibility into what the team is building, what is in progress, and what remains to be done.

2. Azure Repos -  Manage and Collaberate on Code

What problem does it solve?

When multiple developers work on the same application, they need a reliable way to manage code changes, collaberate, and track the history of their work.

Azure Repos provides version control through Git repositories and also supports Team Foundation Version Control (TFVC).

Simple example

Suppose you are developing a python application.

Your project contains:

shopping-app/
├── app.py
├── requirements.txt
└── tests/
    └── test_app.py

You create a Git repository in Azure Repos and push your code to it.

git init
git add .
git commit -m "Initial shopping app"
git remote add origin <repository-url>
git push -u origin main

Replace '<repository-url>'with your actual Azure Repos Git repository URL.

Now imaging another developer needs to implement the shopping cart feature.

Instead of directly changing the main branch, they can create a feature branch, make their changes, and submit a pull request.

The team reviews the changes before merging them into the main branch.

Why does it matter?

Azure Repos helps teams maintain code history, collaberate safely, review changes, and integrate code with the automate build and deployment workflows.

3. Azure Pipelines - Automate Builds, Tests and Deployments

What problem does it solve?

Manually building, testing, and deploying an appplication every time code changes is time-consuming and error-prone.

Azure Pipelines automates these activities using Continuous Integration and Continuous Delivery or Deployment (CI/CD) workflows.

Simple example:

Suppose a developer pushes updated code to Azure Repos.

You want the following activities to happen automatically:

1. Download the source code.
   
2. Install the required dependencies.
3. Run automated tests.
4. Build the application.
5. Deploy it to a test environment if the required checks pass.

You can configure an Azure Pipeline to perform these steps.

For example, a simple YAML pipeline for a python application might look like this:

trigger:
  - main

pool:
  vmImage: ubuntu-latest

steps:
  - task: UsePythonVersion@0
    inputs:
      versionSpec: '3.x'

  - script: |
      python -m pip install --upgrade pip
      pip install -r requirements.txt
    displayName: Install dependencies

  - script: |
      python -m unittest discover -s tests
    displayName: Run unit tests

This example runs when changes changes are pushed to the 'main' branch. It installs dependencies and runs the application's unit tests.

Important: This is a basic CI pipeline. It does not yet build a deployable package or deploy the application. Those stages can be added as the project evolves.

Why does it matter?

Azure Pipelines reduces repetitive manual work and helps teams detect problems earlier, deliver changes more consistently, and implement automated release processes.

4. Azure Test Plans - Organize and Track Testing.

What problem does it solve?

An application can build successfully and still contain functional defects.

Automated unit tests are useful, but teams may also need structured manual testing, exploratory testing, and formal test execution tracking.

Azure Test Plans supports test planning, test cases, test suites, and test execution management.

Simple example:

Your shopping application has a new shopping cart feature.

You want to verify the following scenarios:

A tester can organize these scenarios into a test suite, execute the tests, record the results, and report bugs when something fails.

For example, if removing a product does not update the cart total, the tester can report the defect and link it to the relevant work item.

Why does it matter?

Azure Test Plans helps teams organize testing activities, maintain visibility into test results, and track defects throughout the development lifecycle.

It complements automated testing in Azure Pipelines rather than replacing it. 

5. Azure Artifacts -  Manage and Share packages

What problem does it solve?

Applications frequently depend on reusable libraries, shared components, and packages created by other teams.

Teams need a reliable way to store, version, share, and control access to these packages.

Azure Artifacts provides package feeds for supported package types, including npm, NuGet, Maven, Python packages, and Universal packages.

Simple example:

Imagine your organization develops a reusable Python library called 'company-utils'.

Instead of copying the library's source code into every application, your team publishes a versioned package to an Azure Artifacts feed.

Another application can install it using pip:

pip install company-utils

This command assumes the package is available through a configured package index or feed, and the necessary authentication and package version settings are in place.

Teams can publish an updated version when the library changes and manage which versions applications consume.

Why does it matter?

Azure Artifacts supports package reuse, dependency management, version control, and collaboration across development teams.

How do these five services work together?

Lets connect the services using our online shopping application.

Think of the following workflow:

Plan -> Code -> Build and Test -> Package -> Deploy

Here's where each service fits.

These services work together, but they are not a mandatory linear sequence.

For example, Azure Test Plans can be used alongside automated testing, while Azure Artifacts is only needed when the workflow requires package management.

Deployment itself is typically handled through Azure Pipelines or another deployment tool.

A Practical Beginner project

To learn Azure Devops hands-on, don't try to master all five services independently.

Build one small project and connect the relevant services.

Project: Build and Deploy a Simple Web Application

Start with a basic python application.

Step 1 - Azure Boards

Create a project and add a User Story:

"As a user, I want to access a simple web application through a browser."

Create tasks for application development, testing, and deployment.

Step 2 - Azure Repos

Create a Git repository and commit the application code. Use a feature branch and pull request to practise code collaboration.

Step 3 - Azure Pipelines

Create a YAML pipeline that installs dependencies and runs automated tests. Once the CI workflow works, add a build stage and deployment stages.

Step 4 - Azure Test Plans

Create test cases for application availability, expected page content, and error handling. Record the test execution results.

Step 5 - Azure Artifacts

As an extension, create a small reusable Python package, publish it to an Azure Artifacts feed, and configure the application pipeline to consume it.

By completing this project, one will understand not just how to configure Azure DevOps services, but also why they exist and how they support software delivery.

Final Thoughts

Azure DevOps becomes easier to understand when you stop treating it as a collection of product names and start viewing it as a software delivery platform.

You don't need to master everything on day one. Start with the purpose of each service, build a small project, and gradually connect the services into a practical workflow.

The Goal isn't to memorize the five services. It's to understand how a team takes an idea and turns it into working software.