On this page

Use the Azure DevOps integration when a team's work already lives in Azure DevOps Boards and you want it visible, plannable, and reportable in DevStride without re-keying it. DevStride imports the projects you choose, recreates the iterations that hold work as time boxes and boards, and then keeps the imported items and their comments current as work items change in Azure DevOps. Turn on two-way sync for a project and edits, moves, new items, archives, deletes and internal comments made in DevStride are sent back to Azure DevOps too.

Setup has two stages: create a Credential that connects an Azure DevOps organization, then map that organization's projects and work item types onto your DevStride data model and import.

Azure DevOps Services (dev.azure.com)

The integration connects through Microsoft sign-in and reads your organization at dev.azure.com. There is no setup path for Azure DevOps Server (on-premises).

To reach the integration, open Configure Settings → Integrations → Azure DevOps. The Integrations group also lists Credentials, which is where the connection itself is made. You need Manage Integrations to see these entries.

Before you start#

  • You need the Manage Integrations permission (Owner and Admin have it by default).
  • The Azure DevOps account you connect must be able to grant DevStride the vso.identity, vso.project_manage, and vso.work_full scopes, and must be allowed to create service hooks in each project you import, which in Azure DevOps normally means being a Project Administrator of that project. DevStride registers the hooks for you at the end of an import. If Azure DevOps refuses them, your items still import and the job finishes with a warning (see Change notifications).
  • Every DevStride Item Type you map a work item type to must have point effort enabled with the Decimal type, because Azure DevOps Effort is carried across as points. DevStride refuses any other Item Type with Please select a work type that supports decimal point effort.
  • Your organization needs a default invite role. People who appear on imported work items but are not yet DevStride users are added with that role (see Users).
  • Syncing runs only while your DevStride subscription is active. Webhook-driven updates are skipped when the subscription is inactive.

Credentials#

Credentials store the authorization DevStride uses to talk to Azure DevOps. The Credentials page and its Add Credential dialog are shared with the Jira integration; the steps are the same, with the Provider set to Azure DevOps:

  1. Go to Configure Settings → Integrations → Credentials and click Add.
  2. Enter a Label, set Provider to Azure DevOps, and click Create. A Microsoft sign-in popup opens; complete it to authorize DevStride. Your Microsoft administrator may have to approve DevStride first. If you sign in with a personal Microsoft account (such as Outlook.com or Hotmail), click Connect this way instead under the form rather than Create.
  3. Each Azure DevOps organization the account can reach appears under the credential. Click Connect next to the one you want. Once installed, the row offers Configure (which opens the Azure DevOps page) and Disconnect.

Finish the sign-in in the browser where you started it. If you send the link to someone else, or the approval finishes in another browser, DevStride refuses it and connects nothing. Your own attempt still works afterwards. If someone else needs to sign in, have them start it from their own DevStride session.

Use Edit on a credential to rename it or Delete it. Deleting a credential disconnects every organization installed through it (see Disconnecting).

If you open the Azure DevOps page before connecting an organization, you will see a Connect Azure DevOps prompt. Connect to get started takes you to the Credentials page.

Moving a connection to Microsoft sign-in#

Microsoft is retiring the older Azure DevOps sign-in. A connection made through it keeps syncing for now, and the Azure DevOps page offers to move it. Moving keeps everything linked: your mappings, imported items, and change notifications stay as they are, and nothing is imported again.

  1. Open Configure Settings → Integrations → Azure DevOps and expand the organization. A connection on the older sign-in shows This connection uses the older Azure DevOps sign-in, which Microsoft is retiring.
  2. Click Move to Microsoft sign-in. A popup opens. Allow popups for DevStride if your browser blocks it.
  3. Sign in with a work account that can open this connection's projects. Use a Project Administrator of those projects if you can, because Retry change notifications relies on the account that connected the credential.
  4. If Microsoft says an administrator must approve DevStride, ask your Microsoft administrator to approve it, then move again.

As with a new credential, the sign-in has to finish in the browser where you clicked the button. If someone else should sign in, have them start the move from their own DevStride session rather than sending them the link.

When the move finishes, the offer is gone and syncing carries on through the new sign-in.

DevStride refuses a move, and the connection carries on as it was, when the account you signed in with:

  • cannot see every Azure DevOps organization the connection serves, or
  • is already the account of another connection in your DevStride organization.

Personal Microsoft accounts

Microsoft's new sign-in does not work yet for personal Microsoft accounts (such as Outlook.com or Hotmail), or for an Azure DevOps organization that belongs to them. Those connections stay on the older sign-in for now.

If a connection on the new sign-in runs into trouble because its account lost access, the same place offers Sign in with a different account. It works the same way.

1 - Pick the projects to set up#

Once an organization is connected, open Configure Settings → Integrations → Azure DevOps. Each connected organization is an expandable section headed by its base URL, with these controls:

  • Raw config — view the mapping configuration as JSON.
  • Save changes — appears as soon as you have unsaved mapping edits.
  • A Configuration / Import Jobs toggle to switch between mapping setup and import history. A pulsing dot on Import Jobs means a job is still running.
  • Disconnect and + Connect another organization, both of which take you to the Credentials page.

Under Select projects to setup, every project in the organization is listed with its state and last-updated time. Toggle a project on to configure it. Turning a project on or off is saved immediately; everything else waits for Save changes.

2 - Map each enabled project#

Expanding an enabled project shows its mapping form. Set the two project-level choices first:

  • Status Collection — Select a Status Collection that should be used to setup the boards for this project. DevStride uses it for the boards it creates from your iterations.
  • Workstream — Select a Workstream where the items for this project should be placed. Imported items that have no imported parent land here.

Teams#

Under Azure DevOps Team → DevStride Team, each project team is listed. Team mapping decides which work items are imported at all, and which DevStride team they belong to: at import time DevStride reads each mapped team's area paths and imports only the work items whose Area Path is one of them, giving each item that DevStride team. Work items in areas that belong to no mapped team are not imported, so a project needs at least one team chosen before it can be imported.

To choose a team, click Choose a team on an Azure DevOps team's row and pick the DevStride team its work belongs to. Clear the choice to stop importing that Azure DevOps team's areas. Infer team mappings fills the rows for you; check what it chose before you save.

Work types#

The Azure DevOps Work Types list shows the work item types from the project's process that live on a backlog: portfolio backlog types (Epic, Feature), the requirement backlog type (User Story, Product Backlog Item, or Requirement), the task backlog type, and the bug type. Other work item types are not offered and are not imported.

Select a work type, then choose the DevStride Item Type it should map to. Each work type shows how complete its mappings are as a percentage. For every mapped work type, open its sections and map:

Section Maps Notes
Statuses Azure DevOps Work Item State → DevStride Board Status Statuses come from the project's Status Collection, so pick that first. States in the Removed category are not listed.
Tags Azure DevOps Tag → DevStride Tag DevStride tags come from the Item Type's tag collection. Unmapped Azure DevOps tags are dropped on import.
Priority Levels Azure DevOps Priority → DevStride Priority Level The Azure DevOps side lists the work type's allowed Priority values; the DevStride side comes from the Item Type's priority collection.

Custom Fields are not mapped

A Custom Fields section (Map your Azure DevOps Fields to DevStride Custom Fields) appears in the form, but field mapping is not active for Azure DevOps: the section has no editor and nothing from it is saved or synced. Required custom fields on the target Item Type are filled with their default values on import.

Auto-map with Infer

Every level has an Infer button. Infer project mappings fills the whole project (teams, statuses, tags, and priorities for all work types); Infer all work types and Infer work type mappings match one or all work types to Item Types and fill their sections; and each section has its own Infer team / status / tag / priority mappings. The dropdown next to each button offers Infer by heuristics or Infer from another project, which copies exact matches from a project you already mapped and infers the rest. Inference never overwrites a mapping you already made, and you can run it more than once. Review the result before saving.

When your mappings are ready, click Save changes. If you leave the page with unsaved edits, DevStride warns you first.

3 - Import a project#

Click Initiate import on a project. The button stays disabled while you have unsaved changes, while another Azure DevOps job is still running, or until at least one Azure DevOps team has a DevStride team chosen (see Teams); its tooltip says which. An import needs the project's Status Collection and Workstream set; DevStride tells you which one is missing.

Imports run as jobs that you can follow on the Import Jobs tab. Each row shows the job type, when it started and last updated, who started it, the latest message, and its status; expand a row for the job's input, output, progress, and any errors. The list refreshes every 30 seconds.

Only one import of a project runs at a time: while one is in progress, DevStride refuses another import of the same project, from any browser or the API, so a project is never imported twice side by side. A job stays running until the whole import has finished, even when some items fail along the way; those items are listed in the job's errors when it ends.

An import runs these steps in order:

  1. Iterations — DevStride creates a Cadence named <Project> Iterations (two-week, overlapping time boxes allowed) and a Board Folder named after the project that uses your Status Collection. Each Azure DevOps iteration that holds work becomes a time box in that cadence (with its board) when it has start and finish dates, or a plain board named after the iteration when it does not. Iterations with no work are skipped (see Sprints). Both the parent Workstream and the board folder are opened to the whole organization at Editor level if they were not already.
  2. Areas — the area paths of each mapped team are recorded so items can be assigned to teams. If no team is chosen for the project, the import stops here with No DevStride team is chosen for this project, so there is nothing to import, rather than finishing with nothing imported.
  3. Work items — for each mapped work type, in parent-before-child order, every work item in the mapped teams' area paths (except those in the Removed state) is imported, replaying its revision history so that the DevStride item's history reflects who changed what in Azure DevOps, and when. A few items are brought in at a time, and an item that collides with another being placed at the same moment waits and tries again, so a large project imports steadily instead of failing part-way.
  4. Parents — a child that was imported before its parent waits at the top of the project; once every item exists, DevStride moves it under its parent (see Parents). This step adds a Parents re-checked line to the job's messages that counts what moved and what could not, followed by a line naming each child that is not under its own Azure DevOps parent (up to 25 of each kind). If this step runs out of time, the job ends as Completed With Errors and asks you to import the project again to finish.
  5. Service hooks — DevStride registers webhooks on the project so changes keep flowing (see How sync works). If Azure DevOps refuses them, the job finishes as Completed with a warning and says what permission is missing. Your items are already imported.

Azure DevOps is the source of truth for imported items

Items imported from Azure DevOps are overwritten by later Azure DevOps updates. Unless two-way sync is on for the project, any local change you make in DevStride to a synced field can be replaced the next time the source work item changes.

If you change a project's mappings after it has already been imported, DevStride offers to Re-import that project so the new mappings take effect (No, I will do it later leaves existing items as they are). A project with no team chosen is not offered, because its import would have nothing to bring in.

What a work item becomes#

Azure DevOps DevStride
Work item type Item Type (per your mapping), with the type's color
Title, Description Title, Description
State Board status (per your mapping)
Priority Priority level (per your mapping)
Tags Tags (per your mapping; unmapped tags are dropped)
Assigned To, Created By Assignee, author
Start Date, Target Date Start date, due date (both are cleared if the target date is before the start date)
Effort Point effort
Parent link Parent item, if the pair of Item Types is a permitted parent/child; otherwise its nearest permitted ancestor, or the project's Workstream (see Parents)
Area Team (via team mapping)
Iteration Board or time box for that iteration (see Sprints)

Parents#

An imported item goes under the DevStride item for its Azure DevOps parent. When your Item Types do not allow that pair, for example a Task directly under a Feature, DevStride walks up the item's Azure DevOps parents and places it under the nearest one whose Item Type is allowed as its parent. The import, live updates and Sync all follow this rule, so a later change in Azure DevOps does not send the item back to the top of the project, and an item you moved by hand in DevStride stays where you put it.

An item stays at the top of the project, under its Workstream, when no ancestor is allowed, or when the next ancestor up has not been imported or is archived. The import's messages name the items it placed under an ancestor and the ones it left at the top of the project (up to 25 of each), and count the items whose parent is not part of the import.

Sprints#

A sprint appears in DevStride only once work is placed in its Azure DevOps iteration, so your sprint list shows the sprints in use rather than every iteration the project has ever defined. An iteration counts as holding work when it has an item of a mapped work type in a mapped team's area path, and an item's earlier iterations do not count, only the one it is in now. If Azure DevOps will not answer the question during an import, DevStride creates the sprint anyway and notes a warning, so work is never left off its sprint.

  • A future iteration does not appear until something is placed in it. Planning stays in Azure DevOps. As soon as an item arrives, through an import, a live update, or Sync, the sprint is created.
  • A sprint already in DevStride stays, even if its iteration is now empty.
  • A sprint you archive or remove in DevStride stays that way through every import, re-import, live update, and Sync. Items in that iteration simply have no sprint. DevStride does not bring it back; unarchive an archived sprint yourself (from its card's menu) and it takes items again from the next sync.
  • Archiving the project's folder of boards puts away every sprint in it the same way: the import carries on, and items sync onto no sprint until you unarchive the folder. See Boards and folders synced from Azure DevOps or Jira.

Each project also has an Import sprints from Azure DevOps switch in its mapping form, on by default. Turn it off and DevStride creates no new sprints and makes no sprint changes for that project, while sprints already created are kept and items keep the sprint they have. Save your changes for the switch to take effect. If you turn it back on, new items pick up sprints straight away, and a re-import fills in the rest.

Users#

DevStride matches the people on a work item (creator, assignee, last changer) to DevStride users by email. Someone without a DevStride account is created as an imported user and added to your organization with the default invite role; an assignee is also added to the DevStride team mapped to the item's area. Changes are recorded in DevStride as made by that person, at the time they happened in Azure DevOps.

An imported item always keeps the assignee Azure DevOps gives it, even when that person is not a member of the item's DevStride team. Ordinary DevStride items still drop an assignee who is not on the item's team; an item you disconnect from Azure DevOps (Remove association and keep items) follows that rule again from its next change.

How sync works#

At the end of each import, DevStride registers service hooks on the project for work item created, updated, deleted, and restored events, so a change usually arrives within moments. A catch-up every 15 minutes picks up anything those notifications missed. From then on:

  • A new work item of a mapped type is created in DevStride. Work items of unmapped types are ignored.
  • An updated work item is refreshed. DevStride re-reads the work item from Azure DevOps before applying anything, rather than trusting the webhook body, and skips events that are older than what it has already applied. If the item's type is no longer mapped, the DevStride item is archived.
  • A deleted work item is archived in DevStride; its children move up to the project's Workstream. A restored work item is unarchived.
  • A comment added, edited or deleted in Azure DevOps is added, edited or deleted on the DevStride item (see Comments).
  • A parent removed in Azure DevOps moves the item back to the project's Workstream. A parent you set by hand in DevStride is kept.
  • An item moved to a new iteration moves to the matching board or time box; DevStride creates the time box if it has not seen that iteration yet. A sprint you archived or removed in DevStride is the exception (see Sprints).
  • An item that is on no board (its area is not mapped to a team and it is in no sprint) takes its statuses from the organization's default status list. When the state's mapped status is not in that list, the item gets the list's status of the same kind instead, for example In Progress for an active state, never one that finishes or reopens work differently from Azure DevOps. If the list has no such status, the item keeps the status it has. Once Azure DevOps places the item on a sprint, it takes the mapped status from that board. The update is never refused, so the rest of the project keeps syncing.

Sync is one-way, from Azure DevOps into DevStride, until you turn on two-way sync for the project. Until then, nothing you change in DevStride is written back to Azure DevOps.

Because Azure DevOps sets an imported item's status, DevStride's own automation never changes it: with Automate New/Done on, an imported parent does not move to Done when its children finish, or back to New when one reopens. The roll-up still runs for everything else, including an ordinary DevStride parent above an imported item, which follows the imported item's status as Azure DevOps sets it.

Change notifications#

Each notification from Azure DevOps carries a secret that belongs to that project, and DevStride turns away anything without it. You have nothing to set up: a project connected before this protection existed is upgraded automatically on its next import or within about six hours, and keeps syncing until then.

If Azure DevOps refuses to set up notifications, usually because the connected account is not a Project Administrator, the import still brings in your items and the job on Import Jobs shows Completed with a warning. Fix the permission in Azure DevOps, then click Retry change notifications on the project. This redoes only that step, so you do not need to import again.

The 15-minute catch-up#

Every 15 minutes DevStride asks Azure DevOps what changed in each connected project and applies anything it has not seen, even if notifications are refused or a notification went missing. The catch-up works quietly: it sends no emails or notifications and triggers no automations.

An item that cannot be applied is tried again at later runs. After repeated failures DevStride stops trying until the item changes in Azure DevOps or you run the next import, and Sync health shows how many items this affects.

The catch-up also reads each project's recycle bin, so a work item deleted in Azure DevOps is archived in DevStride within about 15 minutes even if its notification was lost or refused. If it is restored in Azure DevOps, the DevStride copy comes back. An item deleted for good stays archived.

Each item in the bin is archived once, so if you unarchive one by hand, the catch-up leaves it alone. If Azure DevOps will not show the bin, Sync health says the run could not finish, the rest of the catch-up still runs, and the bin is read again at the next run.

Sync health#

Each imported project on the Azure DevOps page shows Sync health:

  • Change notifications: on and secured; set up but not yet secured; not set up yet; or refused, with the reason and a Retry change notifications button.
  • Last change received: when Azure DevOps last delivered a change for this project.
  • 15-minute catch-up: how the last run went and when it ran. If it has not run for over 45 minutes, a warning says these details may be out of date.
  • Changes sent to Azure DevOps (with two-way sync on): when the last change was sent, or Nothing sent yet, and, when Azure DevOps refused any, Azure DevOps refused n changes with each item, the fields and Azure DevOps's reason. A comment that did not reach Azure DevOps is listed here too. Click an item number to open it.
  • Items created from DevStride (with two-way sync on): when an item was last created from DevStride, or No item created from DevStride yet.
  • Items not created in Azure DevOps: items made in DevStride that Azure DevOps refused or never answered for, each with the reason. These stay in DevStride only, and each has a note saying why. The list stays after two-way sync is switched off.
  • Items waiting to be created: creates still under way, with how long each has been waiting.
  • Items placed differently (with two-way sync on): items whose parent, sprint or team area differed between DevStride and Azure DevOps before moves were sent. Neither side changes until someone moves the item, which then leaves the list.
  • Azure DevOps comments not brought in: items missing comments from Azure DevOps, for example because Azure DevOps refused to share them. This shows whether or not two-way sync is on. Each item has a note saying why, and leaves the list once its comments arrive.

What does not sync#

  • Attachments and work item history entries. Comments do sync; see Comments for what comes in and what is sent.
  • Custom fields (see the note under Work types).
  • Links other than parent/child (Related, Predecessor/Successor, and so on).
  • Work item types that are not on a backlog in the project's process (for example Test Case, Issue, Impediment).
  • Work items outside the mapped teams' area paths, and work items in the Removed state.
  • Changes made in DevStride, back to Azure DevOps, unless two-way sync is on for the project. Even then, workstreams, sub-items and the order of items stay in DevStride, and a new item stays in DevStride only in these cases.

Two-way sync#

Two-way sync sends the edits and moves you make in DevStride to a synced item back to its Azure DevOps work item. It also creates new items in Azure DevOps, an archive, unarchive or delete in DevStride does the same there, and internal comments are added there too. It is off for every project until someone with Manage Integrations turns it on.

Turning it on#

  1. Open Configure Settings → Integrations → Azure DevOps and expand the project.
  2. Switch on Edits in DevStride update Azure DevOps, below Import sprints from Azure DevOps.
  3. Confirm Turn on two-way sync for project? with Turn on. These changes reach Azure DevOps for everyone who uses it. The confirmation also says that archiving by a person or an automation deletes the item in Azure DevOps (if you have automations that archive items, for example when they are Done, those items are deleted there too), and that internal comments are sent while public replies and customer emails never are.
  4. Click Save changes. Changing only this switch does not offer a re-import.

Switch it off and save to go back to one-way sync. In the project's Raw config the switch is twoWaySync.

What is sent#

  • Fields: title, description, status, assignee, priority, labels, start and due dates, and effort, where the item's Azure DevOps type has the field.
  • Moves: a new parent becomes the item's parent link in Azure DevOps, and a move back to the project's workstream removes the link. A sprint becomes its iteration, and a move off a sprint goes back to the project's root iteration (sprint moves are sent only while Import sprints from Azure DevOps is on). A team becomes its Azure DevOps team's default area.
  • New items: see New items.
  • Archives, unarchives and deletes: see Archiving, deleting and restoring.
  • Comments: internal comments, and their edits and deletions; see Comments.
  • Not sent: workstreams, sub-items and the order of items stay in DevStride only.

In Azure DevOps the changes show as made by the account the connection signs in with. Where Azure DevOps already matches, nothing is sent. An item already edited in DevStride before you turned the switch on is sent the next time it changes, and an item already placed differently in the two tools stays where it is until someone moves it.

Statuses. A status is sent as the Azure DevOps state mapped to it. When several states map to the same DevStride status, the work type's Statuses section shows Send to Azure DevOps as for that status (only while two-way sync is on): pick the state to send. Until you choose, the first mapped state is sent. A status, priority or assignee that has no match in the project's mapping is not sent; DevStride shows Azure DevOps's value again and adds a note saying so. A label with no matching Azure DevOps tag stays in DevStride only.

New items#

While two-way sync is on, an item you create directly under the project's workstream, or under an item synced with that project, is created in Azure DevOps too. That holds however it is created: quick add, an item's child items, AI add, a copy, a template, bulk, the API or MCP. The Azure DevOps work item gets the item's title, description, status, assignee, priority, labels, dates and effort, its team's area, its sprint, its parent, and a link back to DevStride. The two are then linked, so later edits flow both ways. In Azure DevOps it shows as made by the account the connection signs in with.

Which type it becomes. Under Items created in DevStride in the project's settings, each DevStride item type shows its Azure DevOps type. When several Azure DevOps types map to one DevStride type, choose the one new items become.

Which area it goes in. An item with a team goes in its Azure DevOps team's default area. An item with no team takes its parent's area or, under the project's workstream, the default area of a linked team. DevStride only uses an area it follows, so later changes in Azure DevOps keep coming back.

The create window tells you first. It shows Will also be created in Azure DevOps as type, or why the item stays in DevStride only.

An item stays in DevStride only, and says so in an internal note, when:

  • no Azure DevOps type is mapped to its type;
  • its team is not linked to an Azure DevOps team, or that team's area can't be used;
  • no linked team has an area DevStride follows;
  • its parent is gone in Azure DevOps;
  • Azure DevOps refused it or never answered, or the sign-in expired. These also appear under Items not created in Azure DevOps in Sync health, and items added under such an item stay in DevStride only too;
  • two-way sync was switched off, or the item was deleted, before it was sent;
  • it is a Service Desk ticket, or it came from an import.

Items that were already in the project when you turned the switch on are not created in Azure DevOps. Neither is a DevStride-only item you later move under a synced item, or an item under a sub-workstream of the project's workstream.

If Azure DevOps refuses part of a create, the item is still created and the rest of its fields are sent right after, so nothing you typed is replaced by an empty value. Where Azure DevOps picks a value of its own, for example the first state its process allows, DevStride shows that value and adds a note. If the answer from Azure DevOps is lost, DevStride looks for the work item it already made before trying again, so neither tool ends up with a duplicate. A create still waiting after 15 minutes is sent again by the catch-up.

Archiving, deleting and restoring#

While two-way sync is on, these actions on a synced item reach Azure DevOps. The confirmations say so before anything happens.

In DevStride In Azure DevOps
Archive, by a person or an automation The work item is deleted, into the recycle bin, where it can be restored. Its child items synced with Azure DevOps are archived and deleted with it.
Unarchive The work item is restored from the recycle bin. Child items are restored only if you unarchive them too.
Delete, or permanent delete DevStride stops syncing the item. If it is still live in Azure DevOps it is deleted, into the recycle bin; Azure DevOps keeps its copy.
Archive or delete a workstream inside the project's workstream The same happens to the synced items in it.

DevStride never destroys anything in Azure DevOps: a work item only ever goes to the recycle bin, and how long it stays there is up to Azure DevOps.

  • Archiving automations. A workflow's archive action counts like any other archive, so a "when Done, archive" rule deletes each completed synced item in Azure DevOps.
  • Items archived before the switch are not deleted in Azure DevOps when you turn it on. Permanently deleting one later deletes it there if it is still live.
  • A refusal puts things right. If Azure DevOps refuses a delete, the item is unarchived here so both sides match; if it refuses a restore, the item is archived here again. A note gives the reason, and the refusal is listed in Sync health.
  • An expired sign-in leaves the two tools different, and a note on the item says so and what to do after you reconnect.
  • A work item gone from the recycle bin too. Unarchiving keeps the item in DevStride only, with a note, and it is no longer linked.
  • A type no longer mapped. Its work item is not deleted in Azure DevOps, and a note on the item says so.

Deletions reported by Azure DevOps are checked too. While the switch is on, DevStride confirms with Azure DevOps that a work item is really gone, or really back, before it archives or unarchives anything, so a mistaken notification changes nothing. When Azure DevOps deletes a parent, anything still live under it moves up to the project's workstream. An item that can't be moved clear is archived here and stays live in Azure DevOps, with a note: unarchive it to sync it again.

Editing synced items#

With the switch on, a synced item's fields and its parent, sprint, team and order can be changed in DevStride wherever you edit items: the item drawer, boards, the items table, bulk edit and the roadmap. It can also be archived, unarchived and deleted, and you can add comments to it. Everything else about an imported item stays read-only (see Working with imported items).

Moves Azure DevOps can't follow#

While two-way sync is on, DevStride refuses a move before anything changes, with a message saying why, when Azure DevOps could not follow it:

  • a parent outside the project's workstream;
  • a parent that is a DevStride-only work item, or a work item synced with another project or connection. Moving the item under a workstream inside the project's workstream, or under the workstream itself, is fine;
  • clearing the team, a team that is not linked to any of the project's Azure DevOps teams, or a linked team whose areas would bring the item back as another team.

A bulk edit refuses only the items that can't move and changes the rest. Changes that come from Azure DevOps are never refused.

When both tools change an item#

DevStride merges field by field. A change arriving from Azure DevOps applies only the fields it changed, so your DevStride edits to other fields are kept and still sent. The same goes for moves: a DevStride move still waiting to be sent survives an unrelated Azure DevOps change and is sent after it.

When both sides changed the same field, or moved the item, at the same time, Azure DevOps's value is kept and DevStride adds a note to the item, for example This item was changed in DevStride and in Azure DevOps at the same time. Azure DevOps's Priority was kept. The note quotes the DevStride value that was replaced; a replaced description stays in the item's history.

An Azure DevOps rule can also change other synced fields when your change lands, for example clearing the assignee when the status changes. DevStride takes on those changes the same way it takes on any change from Azure DevOps, and adds no note. A field you just sent keeps your DevStride value, even if the rule changed it in Azure DevOps.

When Azure DevOps refuses a change#

If Azure DevOps refuses part of a change, for example a value its rules reject or a parent link it won't take (such as a move that would make an item its own ancestor in Azure DevOps), the rest of the edit still lands. The refused field or move is put right: DevStride shows Azure DevOps's value again and adds a note to the item, Azure DevOps did not accept the change to field: reason. The refusal is also listed under Changes sent to Azure DevOps in Sync health. A change that fails only because Azure DevOps is briefly unavailable or busy is not a refusal: DevStride tries it again. A move DevStride finds it cannot send after all, such as one to a sprint whose iteration is no longer in Azure DevOps, is put back the same way, with a note giving the reason. If Azure DevOps keeps changing the item so that DevStride can't send its change, the note says so and DevStride shows Azure DevOps's values.

Notes are internal notes on the item, added by DevStride once for each problem.

Comments#

Comments from Azure DevOps#

Comments on a synced work item come into DevStride for every imported project, whether or not two-way sync is on. An import brings in each item's existing comments. After that, a comment added in Azure DevOps appears on the DevStride item within moments, or at the next catch-up, and its later edits and deletion follow.

  • They arrive as internal comments, so customers never see them.
  • Each shows as written by the matching DevStride member, matched by email like the people on work items. When the author cannot be matched, the comment starts with From Azure DevOps, by name.
  • Mentions arrive as plain text (@Name), and the person is not notified in DevStride. Images show as (image in Azure DevOps).
  • Comments brought in by an import or the catch-up, or written more than a day ago, send no notifications.
  • Editing or deleting one of these comments in DevStride changes it only in DevStride. A comment you delete here stays deleted, even if it is edited again in Azure DevOps.

With two-way sync off, you can reply to these comments in DevStride, but you cannot start a new comment on the item, and nothing is sent to Azure DevOps.

Comments sent to Azure DevOps#

While two-way sync is on, an internal comment you write on a synced item is added to its Azure DevOps work item, and your later edits and its deletion follow. The comment box says so before you post: Internal comments are also added in Azure DevOps, posted by the account that connected Azure DevOps.

Because Azure DevOps shows that account as the author, DevStride starts each comment with a line naming who wrote it: From DevStride, by name. Azure DevOps has no threads, so a reply adds a second line, Replying to name. Mentions and item numbers are sent as plain text, and images, videos and GIFs as (image in DevStride).

These stay in DevStride:

  • Replies to the customer and customer emails, and replies under them. The comment box says Replies to the customer are not sent to Azure DevOps.
  • New comments on a Service Desk ticket (New comments on a ticket are not sent to Azure DevOps.). Edits and deletions of comments already sent still follow.
  • Anything on an archived item (This item is archived, so comments are not added in Azure DevOps.), including edits and deletions of comments already sent.
  • Comments written before two-way sync was turned on, and DevStride's own notes.

A comment written while its item is still being created in Azure DevOps is sent once the two are linked. If Azure DevOps refuses a comment, or the sign-in has expired, an internal note on the item names the comment and the reason, and the problem is listed in Sync health. If someone edits a comment in Azure DevOps that was written here with images, mentions or item numbers, DevStride takes Azure DevOps's version, and a note says those are now plain text.

Working with imported items#

An item imported from Azure DevOps shows an imported badge with the Azure DevOps icon. Selecting it opens a popup with:

  • This item was imported from Azure DevOps (or This workstream houses items imported from Azure DevOps on the parent Workstream).
  • View source item — opens the work item in Azure DevOps.
  • Sync — re-reads the work item and its comments from Azure DevOps and applies any changes DevStride has not yet seen. If the work item is gone, you are told This work item no longer exists in Azure DevOps, or DevStride can no longer read it. If Azure DevOps refuses to share the item's comments, you are told The item was updated, but Azure DevOps refused to share its comments. See the note on the item.
  • Item Metadata, including the Azure DevOps URL.

Imported items are read-only in DevStride: you can open them, follow relationships and board links, and read everything, but synced fields cannot be edited and relationships and blockers cannot be changed from the DevStride side. Comments that came from Azure DevOps can be replied to. With two-way sync on for the project, the fields it sends and the item's parent, sprint, team and order can be changed, the item can be archived, unarchived and deleted, and new comments can be added; the rest stays read-only.

Disconnecting#

You can disconnect at three levels. Each asks what to do with the items that came from Azure DevOps:

  • Remove association and keep items — items stay in DevStride as ordinary, editable items with no link back to Azure DevOps.
  • Permanently delete items — the imported items are deleted.

Both choices are irreversible; recovering the items means a full re-import.

Disconnecting never deletes work items in Azure DevOps: two-way sync is switched off first, whichever choice you make.

Scope Where What happens
One project Toggle the project off on the Azure DevOps page Prompts for the item behavior if the project has been imported; a disable job runs
One organization Disconnect next to the organization on the Credentials page Removes the installation and its service hooks; Installation disconnection initiated. Please refresh in a few minutes.
The credential Edit → Delete on the Credentials page Disconnects every organization installed through the credential; Credential deletion initiated. Please refresh in a few minutes.

Troubleshooting#

Symptom Cause and fix
Initiate import is greyed out You have unsaved changes (click Save changes), another Azure DevOps job is still pending or running (wait for it on Import Jobs), or no DevStride team is chosen for the project (see Teams). Hover the button to see which.
Please select a status collection to continue / Please select a workstream to continue Set both project-level fields, save, then import.
Please select a work type that supports decimal point effort Enable point effort with the Decimal type on the Item Type under Configure Settings → Data Model → Item Types, or pick another Item Type.
A project's work item types are missing from the list Only backlog-level types (portfolio, requirement, task, and bug) are offered. Check the project's process configuration in Azure DevOps.
The import completes but brings in fewer items than expected Only work items whose Area Path belongs to a mapped team are imported. Choose a DevStride team for the missing Azure DevOps teams (see Teams), save, and re-import.
The import fails with No DevStride team is chosen for this project, so there is nothing to import. Choose a DevStride team for at least one Azure DevOps team in the project's settings, save, and import again.
The import fails with Organization has no default invite role configured. People on the work items could not be added as DevStride users. Set a default invite role for the organization and run the import again.
An import shows Completed with a warning saying the Azure DevOps account connected to DevStride must be a Project Administrator of the project Azure DevOps refused the service hooks. Your items are imported, and the catch-up brings changes across every 15 minutes rather than within moments. Make that account a Project Administrator of the project (or give it the Edit subscriptions and View subscriptions permissions), then click Retry change notifications on the project. The account that matters is the one that connected the credential, not the person who started the import.
Changes in Azure DevOps stop arriving Open the project's Sync health, which shows whether notifications are on and when the catch-up last ran. Check that your DevStride subscription is active. Retry change notifications sets the hooks up again without an import.
DevStride asks you to reconnect the integration Azure DevOps reported that the stored authorization has expired or been revoked. On the Azure DevOps page, click Move to Microsoft sign-in or Sign in with a different account (see Moving a connection); everything stays linked and syncing resumes on the next event.
  • Jira — the same Credentials page and mapping model
  • Item Types — enabling decimal point effort and permitted parents
  • Connect AI & the MCP Server — the MCP tools list_integration_installations, create_integration_installation, and submit_integration_job work with Azure DevOps installations too
Powered by DevStride