From Backlog to Delivery: Running Scrum in Azure DevOps

This is a practical, end-to-end guide to run Scrum with Azure DevOps — from backlog grooming through sprint delivery and continuous deployment. It blends Scrum practices with Azure DevOps features (Boards, Repos, Pipelines, Test Plans, Artifacts) so your team can deliver predictably and iterate quickly.

1 — Foundations: Roles, artifacts & mapping to Azure DevOps

Scrum roles

• Product Owner — owns Product Backlog (Azure Boards: Product Backlog view / Epics, Features, Product Backlog Items).
• Scrum Master — facilitators, removes impediments, enforces process.
• Development Team — implements work, updates Azure Boards, creates branches/PRs, runs pipelines.

Key Scrum artifacts → Azure DevOps

• Product Backlog → Work Items: Epics → Features → Product Backlog Items (PBIs) / User Stories
• Sprint Backlog → Iteration backlog (sprint iteration path)
• Increment → Builds/Artifacts + Release pipeline deployment (Environments)

Work item types & fields

• Use default or customized types: Epic → Feature → User Story (PBI) → Task → Bug
• Key fields: Title, Description (ACs), Acceptance Criteria, Effort/Story Points, Priority, Iteration Path, Area Path, State, Assigned To, Tags.

2 — Backlog management & readiness

Backlog structure

• Create Epics > Features > User Stories; order by priority (drag & drop).
• Use tags and custom fields to filter (e.g., component:payments, risk:high).

Definition of Ready (DoR)

• Minimum acceptance criteria written
• Story points estimated (PO + Team)
• Dependencies identified
• UX mockups attached (if needed)
• Backend contracts/API described
• Test cases outlined or placeholder created

Azure DevOps practices

Use Backlog view and Board columns mapped to workflow states.

Use Queries to create “Ready for Sprint” lists (e.g., Iteration Path = Unassigned AND State = New AND StoryPoints > 0 AND Tags CONTAINS Ready).

Create Templates for recurring story patterns (API story, bug fix) to speed creation.

3 — Sprint planning & committing items

Sprint planning steps

1. PO presents top backlog items.
2. Team discusses, decomposes stories into tasks.
3. Estimate tasks (hours) for Sprint capacity.
4. Commit stories until capacity filled.

• Assign iteration path to chosen sprint (drag stories into sprint).
• Use Capacity tool (Sprint → Capacity) to set team member availability and check workload.
• Create tasks under each story, set remaining work estimates.

4 — Boards, workflow & visualization

Board setup

• Configure board columns mapping to states (New → Active → Resolved → Closed).
• Add swim lanes for priority or types (Expedite, Bugs).
• Card styles: show Story Points, Assigned To, Tags, custom fields.

Kanban policies

• WIP limits per column can be simulated with queries and dashboards.
• Use Board rules to automate transitions (e.g., when PR merged → move card to Resolved).

5 — Development workflow (Git + PRs)

Branch strategy

• Typical: main (release), develop (optional), feature, short-desc, hotfix
• Link branches to work items: include #ID in commit messages to auto-link.

• PR template: description, related Work Item, checklist (unit tests, build ran, code review).
• Set branch policies:
• Require successful build
• Require 1–2 reviewers
• Enforce work item linking
• Optional: enforce signed commits, code owners

• Use Code Review and PR comments for discussion.
• Auto-complete PR when build passes and reviewers approve.

6 — CI / CD pipelines

CI (Build)

• Run on branch push and PR.
• Typical tasks:
• Restore dependencies
• Compile/build
• Run unit tests and code coverage
• Static analysis/linting
• Publish test results & build artifact

CD (Release)

• Use multi-stage YAML or classic releases.
• Stages: dev → test → staging → prod.
• Use Environments in Azure DevOps and approvals for gatekeeping.

• Approvals before deploy to Prod.
• Approvals + checks: manual, Azure Monitor alerts, Business sign-off.

7 — Testing & quality

Unit & Integration tests

• Fail build if unit tests fail. Publish code coverage.

Automated acceptance tests

• Run E2E tests in staging environment as part of release.

Test Plans

• Use Azure Test Plans for manual test cases and exploratory testing.
• Associate test cases to user stories for traceability.

Quality metrics

• Code coverage % (unit)
• Test pass rate
• Technical debt/sonar score

Deployment

• Artifacts from CI used by release pipelines.
• Deploy to Dev for feature validation, then Test/Staging, then Prod.

Feature flags

• Use feature flagging (LaunchDarkly, Azure App Configuration) to release safely.

Monitoring

• Integrate Application Insights for telemetry and errors.
• Dashboards in Azure DevOps to show:
• Build success rate
• Deployment health
• Lead time, cycle time
• Burndown chart (sprint)

Daily Standup

• Use Board view to review In Progress and blockers; quick updates in Teams or comments on work items.

Sprint Review

• Demo completed work (link Work Items to PRs and deployments).
• Mark stories Done if acceptance criteria met and deployed.

Sprint Retrospective

• Use Azure Boards’ Retrospective extension or a simple work item type to capture improvements; track action items as backlog tasks.

Backlog refinement

• Run regularly; update estimates and acceptance criteria.

10 — Reporting & metrics

Key Scrum metrics in Azure DevOps

• Sprint burndown: shows remaining work vs time.
• Velocity: sum of story points completed per sprint.
• Cycle time & Lead time: use Analytics views (Azure DevOps Analytics) or Power BI for advanced reporting.
• Cumulative Flow Diagram: visualize workflow stability and bottlenecks.

Useful built-in reports

• Delivery Plans extension (roadmap cross-team)
• Sprint health widget
• Query-based charts on dashboards

11 — Automations & best practices

Useful automations

• Auto-transition work item when PR merged (Board rule or automation).
• When build fails, auto-post comment to PR and set Blocked tag on work item.
• On deployment, append release notes into work item discussion.

Best practices

• Keep stories small (1–3 days ideal).
• Always include Acceptance Criteria and Definition of Done.
• Enforce branch and PR policies to keep quality consistent.
• Make CI fast (parallel tests, test impact analysis).
• Keep backlog groomed and prioritized; use capacity planning.
• Use templates for Stories, Bugs, and Tasks.
• Maintain a single source of truth: link commits → PR → builds → work items → releases.

• Refinement: PO refines top backlog; team estimates.
• Planning: team selects sprint items, creates tasks, sets capacity.
• Develop: feature branches → PRs → CI validate → merged → automated tests run.
• Deploy: artifact to Dev → QA tests → staging → Prod (with approvals).
• Review & Demo: show working increment.
• Retrospect: capture improvement actions and add to backlog.

Trouble-shooting common pitfalls

• Slow CI builds → parallelize, cache dependencies.
• Unlinked work items/PRs → enforce policy requiring work item in PR title.
• Multiple sources of truth → centralize decisions in Boards and maintain traceability.
• Overloaded sprint → use capacity tool and historical velocity.
• Flaky tests → quarantine and fix to avoid noise.

Closing tip

Start with a lightweight setup: Boards + Git + simple CI. Iterate your process and Azure DevOps configuration as the team matures. Use automation to remove manual handoffs, and always keep traceability from backlog item → commit → build → release.