Use the built-in Bug work item type, keep a Resolved-to-Closed verification step intact, and add no more than one or two gate states like Triaged before development starts. Automate the transitions that people forget: setting state from a pull request, reassigning resolved bugs back to the reporter, and flagging duplicates before they hit the backlog. That combination, backed by Microsoft’s own bug management guidance, handles most teams without touching the process editor at all.
TL;DR:
- Automate bug state transitions from pull requests, reassign resolved bugs to reporters, and flag duplicates early to reduce manual handling and prevent stale tickets.
- Use severity and reason fields consistently at creation, as they are key for effective triage and accurate resolution metrics, especially when tracking bugs as requirements.
- Ensure bug states are correctly mapped to the category buckets, with a verified “Resolved” state between “In Progress” and “Completed,” and validate mappings after any process change.
- Limit custom states to a few meaningful ones, avoiding excessive granularity that complicates boards; ask if tags or filters could replace overly specific states.
- Integrate AI-based duplicate detection during UAT to capture and cluster similar bugs before they reach the backlog, significantly reducing duplicate tickets and triage effort.
Table of Contents
- What Fields Actually Matter in the Bug Work Item Type
- How Do State Categories Affect Bug Visibility?
- How Do You Customize the Bug Workflow Safely?
- Automating Transitions: PRs, Rules, and Reporting Hooks
- Which Queries and Metrics Keep a Bug Backlog Honest?
- Best Practices That Keep the Workflow From Rotting
- Where a UAT Capture Tool With AI Duplicate Detection Fits
- Author perspective: what actually matters when you rebuild a bug workflow
- Capture Cleaner Bugs Before They Ever Reach Azure Boards
- Sources
- FAQ
What Fields Actually Matter in the Bug Work Item Type
The Bug work item type in Azure Boards comes with a specific field set, and each one earns its place. State, Reason, Assigned To, Severity, Area Path, Iteration Path, and Repro Steps aren’t just metadata for filing purposes; they’re the levers your automation, triage queries, and reports all pull.
Severity drives triage priority in most shops, but it only works if people fill it in consistently. Reason matters more than teams expect, because it’s what separates a bug closed because “Fixed” from one closed as “Duplicate” or “Cannot Reproduce.” Without that distinction, your resolution metrics blend real fixes with noise.
One decision shapes everything downstream: whether your process tracks bugs as requirements or as tasks. This setting, found under process configuration, changes which backlog a bug shows up on and whether it counts toward sprint capacity and velocity.
- Bugs as requirements: bugs appear on the Product Backlog and Sprint Backlog alongside user stories, count in velocity, and show up in forecasting tools like delivery plans.
- Bugs as tasks: bugs live under stories as child items, which keeps the backlog cleaner but can hide bug volume from stakeholders who only look at the product backlog.
Neither setting is universally right. Teams shipping to end users where bug volume affects release confidence usually want bugs tracked as requirements, since that keeps defect counts visible in the same forecasting views as feature work. Internal tools teams with low bug volume often prefer tasks, so the backlog stays focused on what customers actually asked for.
Whichever you pick, standardize which fields are required at creation. Making Repro Steps and Severity mandatory costs almost nothing to enforce and pays off the first time someone tries to triage twenty bugs with blank descriptions.
How Do State Categories Affect Bug Visibility?
Every state in Azure DevOps belongs to one of four category buckets, and that category, not the state’s display name, controls how the item behaves on backlogs and boards. Get the mapping wrong and bugs quietly disappear from views your team relies on daily.
The four category states, as defined in Microsoft’s workflow and state category documentation, work like this:
- Proposed covers new, unstarted work. Items here show up in the backlog but not yet on an active board column.
- In Progress marks active work. These items appear in board columns mapped to this category and count toward “in progress” metrics like cumulative flow.
- Resolved signals work that’s technically done but not yet verified. This is the category most teams misuse or skip entirely.
- Completed marks work that’s truly finished. Only one state per work item type can occupy this category, which trips people up during customization.
Default mappings differ by process template. Agile and CMMI use a Resolved state that sits between “fixed” and “verified,” which is exactly the gap QA needs to close a loop. Scrum, by contrast, skips straight from Committed to Done, following its Scrum-specific workflow model. If your team runs Scrum but wants a verify step, you’ll need to add one.
After any state or process change, run this quick validation:
- Open a saved query filtered by the new or changed state and confirm items actually return.
- Check board columns to see whether the state appears where you expect.
- Query the REST API’s state list endpoint to confirm the stateCategory value matches your intent, not just the label.
Skip that check and you’ll find out about a mapping mistake when someone asks why last week’s bugs vanished from the sprint board.
How Do You Customize the Bug Workflow Safely?
Adding a custom state like Triaged or Customer Verified is straightforward in an inherited process, but the constraints around it matter more than the button-clicking. Get the constraints wrong and you’ll break dashboards you didn’t know depended on the old state names.
The actual steps, per Microsoft’s process customization guide, go like this:
- Navigate to your process, select the Bug work item type, and open the States tab.
- Add a new state, give it a name (Triaged, Investigating, whatever fits your team’s language), and assign it to a category.
- Save the change, then immediately open a test work item and walk it through the new state to confirm the transition behaves as expected.
- Map the new state to a board column if it needs board visibility, since new states don’t automatically appear on existing boards.
The constraints you’re working within aren’t arbitrary:
- Every work item type needs at least two category states represented, so you can’t collapse everything into one bucket.
- Only one state can sit in the Completed category at a time. You can’t have more than one state marked Completed.
- Inherited states that ship with the process (Active, Resolved, Closed) can’t be renamed, only supplemented with new ones.
- A work item type maxes out at 32 states total, which sounds generous until a team starts adding one state per workflow edge case.
Here’s the part that actually determines whether your workflow helps or hurts: fewer, meaningful states beat granular ones almost every time. A workflow with Active, Triaged, Resolved, and Closed tells a clear story. One with Active, In Review, Blocked, Waiting on Vendor, Investigating, Resolved, Verified, and Closed turns your board into a maze nobody updates correctly, and half those distinctions can live in a tag or a query filter instead of a state.
Pro Tip: Before adding a new state, ask whether a tag or a saved query could capture the same distinction. States belong on the board because people need to see them at a glance. Everything else belongs in a filter.
Automating Transitions: PRs, Rules, and Reporting Hooks
The single highest-leverage automation in any Azure DevOps bug workflow is setting state directly from a pull request. Include a line like Resolves: #1423 or a state directive in your PR description, and when that PR merges, the linked bug automatically moves to Resolved, according to Microsoft’s guidance on bug management. No developer has to remember to open the work item and click a dropdown.
That one habit alone eliminates a huge share of stale “should be resolved but nobody updated it” tickets. A few other rules are worth setting up alongside it:
- Auto-reassign on resolve: when a bug moves to Resolved, reassign it to the original reporter automatically. This creates a verification loop that keeps tickets from sitting in Resolved indefinitely, echoing the accountability pattern Microsoft’s own documentation recommends.
- Auto-notify on state change: trigger an email or Teams message when severity-1 bugs change state, so nobody has to poll the board to catch a critical fix.
- Auto-close after a verification timeout: if a Resolved bug sits untouched for a set number of days, close it automatically with a Reason of “No Response,” rather than letting it decay silently.
For teams that need integrations beyond native rules, three options cover most cases, including using Agent Evaluation & Testing to deploy external UAT agents. Service hooks push events to external systems in near real time. Power Automate builds no-code flows for cross-tool notifications and approvals. OData feeds let you pull work item and state data into Power BI or another reporting layer for trend analysis, which pairs well with the cumulative flow and dashboard reporting Azure DevOps already supports natively.
Before rolling any of this into production, test it on a sandbox project, confirm the rule fires on the exact trigger you expect, and check that it doesn’t collide with an existing rule. Teams that skip this step tend to discover the conflict when a bug bounces between two states in a loop.
Which Queries and Metrics Keep a Bug Backlog Honest?
A handful of saved queries do most of the triage work. Build these once and reuse them every sprint:
- New and unassigned bugs: catches anything that slipped through intake without an owner.
- Active bugs by priority: sorted by Severity, this is the list a triage meeting should open first.
- Stale resolved items: bugs sitting in Resolved past your verification window, the exact set your auto-close rule should be watching.
- Bugs by area path: useful when a specific module starts generating disproportionate volume.
Triage itself works best as a short, recurring meeting where someone pulls up the “new and unassigned” query live, walks through each item, and either assigns it, tags it as a duplicate, or bounces it back to the reporter for more detail. Teams using Azure Boards’ triage mode can flag items directly from the query results grid instead of opening each work item individually, which keeps the meeting under twenty minutes even with a full backlog.
For metrics, keep it to a small set that actually gets looked at:
- Time-to-fix: from Active to Resolved.
- Time-to-verify: from Resolved to Closed. This is the metric most teams skip, and it’s often where the real delay hides.
- Active bug trend: a simple count over time, visualized well through a cumulative flow diagram widget on your dashboard.
- Reopened rate: the percentage of Closed bugs that get reopened, a strong signal of whether your verification step is doing its job.
Dashboard widgets built from these queries beat a spreadsheet every time, mostly because they update themselves.
Best Practices That Keep the Workflow From Rotting
Most bug workflow problems trace back to the same handful of mistakes, and they’re avoidable once you know to watch for them.
- Resist adding a new board column for every edge case. Column bloat makes boards unreadable and pushes teams back toward spreadsheets. Use custom states sparingly and lean on queries for anything more granular than the board needs to show.
- Never collapse Resolved and Closed into one step, even under pressure to move fast. That verification gap is what separates “the developer thinks it’s fixed” from “QA confirmed it’s fixed,” and losing it quietly inflates your defect escape rate.
- Automate the reassign-to-reporter step on resolution. It’s the single easiest way to shrink the gap between time-to-fix and time-to-verify.
- Cut duplicates before they reach the backlog by requiring reproduction steps at intake, running new bugs through a triage gate, and tagging known issue clusters so the next reporter finds the existing ticket instead of filing a new one.
Pro Tip: Duplicate tickets are almost always a symptom of poor repro detail, not careless reporters. If two people can’t tell their bug matches an existing one, the existing ticket’s description is the problem, not the second reporter.
Before rolling any workflow change into production, run this checklist: document exactly what changed and why, test the new state or rule in a sandbox project first, update every saved query and dashboard widget that references old state names, and give the team a five-minute walkthrough so nobody’s confused on Monday morning.
Where a UAT Capture Tool With AI Duplicate Detection Fits
Everything above assumes bugs enter Azure Boards already reasonably clean. In practice, the messiest phase happens earlier, during user acceptance testing, when testers file the same issue five different ways because nobody’s checking for overlap before it lands in the backlog.
A UAT capture layer sitting in front of Azure Boards changes that math. Instead of a tester typing a vague description, a tool that records the screen and transcribes the issue in real time captures the actual reproduction steps as they happen, then runs AI-based duplicate detection before the ticket ever reaches your backlog.
The practical integration points look like this:
- Auto-create a Bug work item in Azure Boards complete with transcript, screen recording, and attachments already filled in.
- Seed the initial state (commonly Proposed or your custom Triaged state) and apply tags automatically based on the module or feature area.
- Flag likely duplicates before creation, so testers see “this looks like #1187” instead of filing a fifth copy of the same defect.
Roll this into a staging project first, watch how the AI duplicate flags perform against your real bug patterns for a sprint or two, and adjust before trusting it against your production backlog.
Author perspective: what actually matters when you rebuild a bug workflow
Most teams over-engineer states and under-invest in the two things that actually reduce noise: a verify step nobody skips, and automation that catches what people forget. Add states sparingly. Automate the boring parts. Everything else is decoration.
— Marketing
Capture Cleaner Bugs Before They Ever Reach Azure Boards
Everything in this article assumes bugs arrive at Azure Boards with decent repro detail and no duplicates already baked in. That’s rarely true when UAT testers are typing descriptions by hand under deadline pressure. Some UAT tools close that gap by recording the tester’s screen, transcribing the issue as they talk through it, and running AI duplicate detection before a single ticket touches your backlog, so triage starts with clean, unique reports instead of five versions of the same problem.
For teams already using Azure Boards, the Azure DevOps integration auto-creates bug work items with the transcript and recording attached, seeds the right initial state, and tags likely duplicates before they clutter your triage query. If you’re weighing this against a manual intake process or comparing tools for your UAT phase, the use cases page walks through how teams structure that handoff. Start a trial and see how many duplicate tickets it flags in your first sprint.
FAQ
Should Bugs Be Tracked as Requirements or Tasks?
Track bugs as requirements if leadership needs bug volume visible on the same forecasting views as features; track them as tasks if you want a cleaner backlog focused on user stories. The setting lives in your process configuration and affects velocity calculations either way.
What’s the Difference Between Resolved and Closed?
Resolved means a developer believes the fix is done; Closed means someone, usually QA or the original reporter, has verified it. Skipping straight to Closed removes the verification step that catches false fixes.
Can You Rename a Default Bug State?
No. Inherited states like Active or Resolved can’t be renamed, though you can add new custom states such as Triaged alongside them, up to a limit of 32 states per work item type.
How Do You Set a Bug’s State From a Pull Request?
Include a state directive or a linking keyword tied to the work item ID in your PR description. When the PR merges, Azure Boards moves the linked bug to the specified state automatically.
Does a Duplicate Detection Tool Replace Triage Meetings?
No, but it changes what triage meetings deal with. Some tools flag likely duplicates before bugs reach the backlog, so the triage conversation focuses on genuinely new issues instead of sorting through repeat tickets.
