Azure DevOps for Beginners: Pipelines, Repos, and Boards

Azure DevOps is Microsoft's end-to-end DevOps platform, providing everything a development team needs to plan, build, test, and deploy software. It is a suite of five integrated services that work independently or together: Boards, Repos, Pipelines, Test Plans, and Artifacts. This guide focuses on the three most impactful services for most teams: Boards for work tracking, Repos for source control, and Pipelines for CI/CD.

Getting Started: Create an Organization and Project

Azure DevOps is accessed at dev.azure.com. Sign in with your Microsoft account (or Azure AD account), create an Organization (your company or team name), then create a Project inside it. A project is the container for all your Boards, Repos, Pipelines, and Artifacts.

Choose between Agile, Scrum, or CMMI process templates when creating your project — this affects the work item types available in Boards. Agile is the most flexible starting point for most teams.

Azure Boards: Plan and Track Work

Azure Boards provides Kanban boards, backlogs, sprint planning, and reporting. The core work items are:

• Epics: Large, multi-sprint initiatives (e.g., "Launch mobile app").
• Features: Chunks of deliverable functionality within an Epic.
• User Stories (Agile) / Product Backlog Items (Scrum): Individual user-facing requirements.
• Tasks: Technical subtasks assigned to individual developers.
• Bugs: Defects tracked with the same lifecycle as user stories.

Use the Kanban Board (Boards > Boards) for a visual workflow view with columns like To Do, In Progress, In Review, and Done. Link work items to commits and pull requests so every code change traces back to a requirement.

Azure Repos: Git Source Control

Azure Repos provides unlimited free private Git repositories. Teams familiar with GitHub will find Azure Repos very similar — it supports branch policies, pull requests, and code review workflows.

# Clone your Azure Repo
git clone https://dev.azure.com/yourorg/yourproject/_git/yourrepo

# Work on a feature branch
git checkout -b feature/add-login-page

# Push and create a PR
git add .
git commit -m "Add login page UI"
git push origin feature/add-login-page

Configure Branch Policies on the main branch to enforce:

• Minimum number of reviewers (e.g., 2 approvals required).
• Linked work items — every PR must reference a Boards item.
• Build validation — the CI pipeline must pass before merging is allowed.
• Comment resolution — all PR comments must be resolved.

Azure Pipelines: CI/CD Automation

Azure Pipelines automates building, testing, and deploying your application. Pipelines are defined in a YAML file (azure-pipelines.yml) checked into your repo.

Here is a complete pipeline for a Node.js application that builds, tests, and deploys to Azure App Service:

trigger:
  branches:
    include:
      - main

pool:
  vmImage: ubuntu-latest

variables:
  AZURE_WEBAPP_NAME: myapp-demo-2026
  AZURE_RESOURCE_GROUP: rg-webapp-demo

stages:
  - stage: Build
    jobs:
      - job: BuildAndTest
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: "20.x"

          - script: |
              npm install
              npm test
            displayName: Install and Test

          - task: ArchiveFiles@2
            inputs:
              rootFolderOrFile: "$(System.DefaultWorkingDirectory)"
              includeRootFolder: false
              archiveFile: "$(Build.ArtifactStagingDirectory)/app.zip"

          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: "$(Build.ArtifactStagingDirectory)"
              artifactName: drop

  - stage: Deploy
    dependsOn: Build
    condition: succeeded()
    jobs:
      - deployment: DeployToAppService
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: "MyAzureServiceConnection"
                    appName: "$(AZURE_WEBAPP_NAME)"
                    package: "$(Pipeline.Workspace)/drop/app.zip"

Create the pipeline at Pipelines > Create Pipeline, point it at your repo, and Azure DevOps detects the YAML file automatically.

Service Connections

For pipelines to deploy to Azure, you need a Service Connection — an authenticated link between Azure DevOps and your Azure subscription. Create one at Project Settings > Service Connections > New service connection > Azure Resource Manager. Use Workload Identity Federation (the recommended option) instead of service principal secrets — it requires no credential rotation.

Environments and Approvals

Azure Pipelines Environments let you define deployment targets (development, staging, production) with approval gates. Add a pre-deployment approval to the production environment so a senior engineer must manually approve every production release. This single control prevents accidental deployments and provides an audit trail.

Azure Artifacts: Package Management

Azure Artifacts provides hosted npm, NuGet, Maven, and Python package feeds. Teams use it to share internal libraries across projects without publishing to public registries. Connect your project to an Artifacts feed from the CLI:

# Authenticate npm to Azure Artifacts
npm install -g vsts-npm-auth
vsts-npm-auth -config .npmrc

Key Takeaways

Azure DevOps gives your team a single platform to plan (Boards), version control (Repos), and automate delivery (Pipelines). Start by enabling branch policies on main, creating a YAML pipeline with a build and deploy stage, and adding a production approval gate. These three steps alone dramatically improve code quality and deployment reliability.