Azure DevOps

Five tools in one suite for the whole software lifecycle, plus a quiet, audit-friendly way to ship to Azure Kubernetes Service.

01What’s in the suite

"Azure DevOps" is the umbrella name for five separate products that share a sign-in, a billing account, and a project model. You can use any of them on their own.

Azure Repos
Hosted Git
Azure Pipelines
CI / CD (YAML or classic)
Azure Boards
Backlogs, sprints, work items
Azure Artifacts
Package feeds (npm, NuGet, …)
Azure Test Plans
Manual & user-acceptance testing
AKS
Managed Kubernetes (separate Azure service)

A government department needs a new system. The procurement rules are strict. Every change must be traceable to a numbered work item; every work item must be approved before a feature branch is opened; every build must be linked to the work item it implements; every deploy to production must require a named human approver and generate an immutable audit log.

GitHub can do most of this. Azure DevOps Services was designed for it from day one. The Boards / Repos / Pipelines / Test Plans / Artifacts integration is the reason banks, insurers, healthcare organisations and governments keep choosing it.

On the other side: a startup that ships every two hours doesn’t want any of that ceremony. They use GitHub. Knowing which is which is half the chapter.

02What Azure DevOps Services is — and isn’t

First, some terminology, because Microsoft has overloaded the word "DevOps" several times.

Azure DevOps Services

The hosted SaaS that contains Repos, Pipelines, Boards, Artifacts and Test Plans. One URL per organization. This is the thing most people mean by "Azure DevOps".

Azure DevOps Server

The self-hosted version (formerly Team Foundation Server). Installed in organizations that can’t use SaaS. Same tools, your own SQL Server backend.

"DevOps on Azure"

A separate idea — practising DevOps on the Azure cloud. You can do this with GitHub Actions, Jenkins, GitLab or anything else; Azure DevOps Services is just one option.

03Azure DevOps vs GitHub — both are Microsoft

Microsoft owns both products. They overlap by design. The honest answer to "which should we pick?" depends on the kind of organization you work in.

Azure DevOps Services

  • Enterprise process built in. Boards, Test Plans, Artifacts — one integrated workflow.
  • Mature pipelines. Classic UI pipelines and YAML pipelines coexist.
  • Strong Active Directory & on-prem integration.
  • Best when the question is "show me the audit trail".
vs

GitHub (Enterprise)

  • Modern code review & AI features. Copilot, code search, Actions marketplace.
  • Where Microsoft invests new features first.
  • Open-source friendly culture.
  • Best when the question is "ship faster".
i

A common pattern

Many enterprises now run a hybrid: GitHub for source and code review, Azure DevOps Boards for process. You can sync work items to PRs across both products.

04A real Azure Pipeline that ships to AKS

Modern Azure Pipelines are YAML. This one builds an image, pushes to Azure Container Registry and deploys to AKS using workload identity federation — no stored Azure secret.

azure-pipelines.ymlYAML
trigger:
  branches: { include: [main] }

variables:
  ACR:   course.azurecr.io
  IMAGE: web
  TAG:   $(Build.BuildId)

stages:
  - stage: Build
    jobs:
      - job: Build
        pool: { vmImage: 'ubuntu-latest' }
        steps:
          - task: NodeTool@0
            inputs: { versionSpec: '20.x' }

          - script: npm ci && npm test
            displayName: Test

          - task: Docker@2
            inputs:
              containerRegistry: 'acr-svc-connection'
              repository: $(IMAGE)
              command: buildAndPush
              tags: |
                $(TAG)
                latest

  - stage: Deploy
    dependsOn: Build
    condition: succeeded()
    jobs:
      - deployment: Prod
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - task: AzureCLI@2
                  inputs:
                    azureSubscription: 'wif-svc-connection'   # workload identity
                    scriptType: bash
                    inlineScript: |
                      az aks get-credentials -g rg-prod -n aks-prod
                      kubectl set image deploy/web web=$(ACR)/$(IMAGE):$(TAG) -n prod

05Workload identity — the Azure version of OIDC

Azure DevOps service connections used to require a service principal secret stored in the project. Workload identity federation makes that secret unnecessary.

Register

Create an Entra ID application for the pipeline (or a managed identity).

Federate

Add a federated credential that trusts the Azure DevOps service connection.

Grant

Assign Azure RBAC roles: AcrPush, AKS Cluster User, whatever the pipeline needs.

Connect

The service connection now uses workload identity instead of a secret.

Audit

Sign-in logs show every "assume" by the pipeline. Nothing to rotate, nothing to leak.

06Making Boards actually useful

The killer feature of Azure DevOps is the work-item / branch / PR integration. With a few small conventions, Boards stops being bureaucracy and becomes the team’s memory.

Mention the work item
Every PR description includes #1234; every commit message starts with it. The platform links them automatically.
Short sprints
Two weeks at most, one week if your team is small. Long enough to ship something real, short enough that surprises don’t wreck the plan.
Definition of Ready / Done
Written down, agreed by the team, pinned to the Boards dashboard. The most useful "process" artefact you’ll ever make.
Burn-down in the channel
A bot posts daily burn-down to Slack / Teams. Surprises become Monday meetings, not Friday surprises.

07Habits that keep Azure DevOps usable

These are the small choices that decide whether your Azure DevOps organization stays productive or becomes a maze of clicked-once-five-years-ago settings.

Anti-pattern
Classic UI pipelines for new projects. They’re still supported, but every new project should use YAML pipelines. Code-defined, reviewable, portable.
Anti-pattern
Service-principal secrets in variable groups. The Azure version of "AWS access key in CI secrets". Use workload identity federation instead.
Anti-pattern
One giant pipeline. Twenty stages, branching conditions, undocumented variables. Split by lifecycle, use templates, name things clearly.
Anti-pattern
Process imposed top-down. Boards rules nobody on the team agreed to. Make the process light, agree it as a team, kill the rules nobody enforces.
Healthy
Pipeline templates in a central repo. One canonical "build a Node service" template; every repo extends it. Update the template, every pipeline benefits.

08Putting it together

Take-aways

1. Azure DevOps Services is five tools in one suite: Repos, Pipelines, Boards, Artifacts, Test Plans. AKS is the deploy target.

2. Pick Azure DevOps when audit, process and on-prem matter most; pick GitHub when speed and modern dev culture matter most.

3. Use YAML pipelines, not classic UI. Use workload identity, not service-principal secrets. Use templates, not copy-paste.

4. Make Boards useful with mention conventions, short sprints and shared Definitions of Ready / Done.

That’s the twelve core chapters. Next: the 2026 tools radar and interview flashcards.