TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Process Customization REST APIs

50 posts · May 2005 – Jul 2025

What this trail covers

Azure DevOps process customization continues to evolve with enhancements to work item state transitions, UI modernization for Azure Repos, and expanded capabilities in Azure Pipelines, Azure Artifacts, and reporting. This post introduces the ability to configure work item types (specifically bugs) to appear on either the task board or the product backlog, but not both, by modifying work item definitions and category assignments using the `witadmin` command-line tool. This allows teams to align b

All Microsoft trails
  1. Markdown Support Arrives for Work ItemsThis post announces the general availability of Markdown support for large text fields in Azure DevOps work items. Users can opt-in to use a Markdown editor for fields like Description, Repro Steps, and Acceptance Criteria. Existing HTML content can be converted to Markdown with a best-effort conversion, though this is a one-way operation. New work items can default to Markdown based on user preference. The post also details how to use the REST API to set the format of large text fields to Markdown, including the `/multilineFieldsFormat` operation. The release is being rolled out in stages over 4-5 weeks.
  2. Copy a work item type using Azure DevOps API'sThis post details how to programmatically copy a work item type using Azure DevOps APIs. It addresses undocumented aspects of the API, specifically for handling multi-line text fields (HTMLFieldControl), custom control extensions (like URL fields), and boolean fields, which require specific group and control configurations. The post provides code snippets and explanations for adding fields, groups, and controls to a new work item type, enabling the replication of complex work item structures.
  3. Announcing new REST API's for Process CustomizationIntroduced new REST API endpoints for process customization, consolidating inherited model APIs under a single domain in version 5.0 (preview) and providing separate APIs for Hosted XML processes (checking existence, importing, exporting). Also updated client libraries to version 16.139.0-preview and provided initial samples on GitHub.
  4. What’s new in VSTS Sprint 135 UpdateIntroduced an import/export tool for inherited process customizations, open-sourced on GitHub, to better support workflows where organizations refine process customizations in a separate VSTS account before applying them to their production account. Also highlighted new release progress views for VSTS Sprint 135 Update, presenting artifacts, environments, and deployment progress in a richer, graphical way.
  5. Announcing the deprecation of the WIT and Test Client OMAnnounces the deprecation of the Work Item Tracking (WIT) and Test SOAP APIs, which were part of the Microsoft.TeamFoundationServer.ExtendedClient. All work item and test methods in this client are marked as obsolete starting in Visual Studio 2019 and Azure DevOps Server 2019. The post recommends migrating to the REST APIs for new integrations and provides a deprecation matrix for SOAP and REST APIs across different Azure DevOps Server and Service versions. It also clarifies that while current WIT Client OM functionality is supported, no new features will be added to it.
  7. Creating work item form extensions in Visual Studio Team ServicesThis post details how to write efficient work item form extensions in Visual Studio Team Services (VSTS). It explains the lifecycle of work item forms and their contributions, emphasizing the importance of initializing logic in the 'onLoaded' event rather than the constructor. It describes the five contribution points (Page, Group, Control, Menu, Observer) and the two services (_IWorkItemNotificationListener_ and _WorkItemFormService_) used for interaction. A practical example of a checklist group extension is provided, highlighting the use of TypeScript and the VSS SDK.
  8. Announcing the deprecation of the old Work Item Form in TFSThis post announces the deprecation of the old work item form in TFS and its old extensibility model. It highlights the features of the new work item form, including integrated development control, Follows action, @mention and #ID functionality, and a new extensibility model with custom controls, groups, and pages. It also details improvements to links, attachments, and history controls. A timeline for deprecation is provided, with the old form being removed in the next major version of TFS. Resources for adopting the new form are also shared.
  9. Work Item Visualization is one of many productivity extensions on the marketplaceThis post announces an update to the Work Item Visualization extension, adding annotations, saving visualizations, and a find feature. It also details the history of the extension's development, from its origins as a manual map to its current web-based form integrated into VSTS/TFS, highlighting community contributions and future planned features like filtering link types and sharing functionality.
  10. Announcing Reporting Capabilities for Visual Studio Team ServicesThis post announces the upcoming public preview of advanced reporting capabilities for Visual Studio Team Services, which will eventually replace the on-premises TFS data reporting warehouse. The new service is backed by SQL Server and uses the Open Data Protocol v4, offering custom reporting over VS Team Services data. It highlights the ability to perform aggregations and use tools like Excel, Power BI, and Tableau. Specific OData queries are provided as examples for calculating the sum of remaining work and grouping work items by type. The initial data available will be work item data, followed by version control, test, build, and release data. New reporting capabilities include velocity (estimated and actual), capacity, team filtering, Kanban metrics (median days in state, lead time, cycle time), trend and rollup data, and tags. The post also shows a schema for the work item data model and expects the public preview for work item data in Q3 2016.
  11. Process Template changes to TFS 2015 RTMThis post details updates to process templates for TFS 2015 RTM, including adding an 'Epic' portfolio level, workflow changes for Agile and Scrum work items, and new fields like Priority, StateChangeDate, ID, Effort, Storyboard, Acceptance Criteria, Business Value, Requirement Type, and Time Criticality. It also introduces process inheritance for automatic updates to system processes.
  12. General Availability of Work Item Trend and Rollup Reporting in Power BIAnnounces the general availability of trend and rollup reporting capabilities in the Visual Studio Online Power BI Connector. Enables creation of sprint burndown charts and summary counts of work items under epics, features, or stories. The out-of-the-box report has been redone to provide a more complete view of data, including a new Open Bug Status report page with bug trends. Users need to re-create their connection to Visual Studio Online to take advantage of the new model.
  13. Visual Studio Online Process Customization - UpdateThis post details the rollout plan for process customization in Visual Studio Online, including adding custom fields, modifying layout, creating custom work item types, defining business logic, and importing/exporting custom processes. It introduces the concept of inherited processes, allowing users to extend existing templates without direct modification, and provides UI and REST API support for these customizations.
  14. Reporting on Work Items with Power BIThis post announces the general availability of reporting on work items using Power BI. The initial release supports reporting across team projects, velocity charts, and filtering by area, iteration, tags, and other fields. It also introduces advanced metrics like median days in state and 95th percentile days in state. Future releases will include history and rollup capabilities by the end of August, followed by Kanban data. The post details the data model structure for work items, including core work item dimensions and related dimensions for individual work item types, and explains how to use measures like 'Work Items' and specific measures within dimensions (e.g., 'Bugs') for reporting.
  15. Visual Studio Online Process CustomizationThis post announces the upcoming availability of process customization for Visual Studio Online (VSO), including a private preview for customers to bring their on-premises TFS customized process templates. It introduces the concepts of 'shared process' and 'inherited process' to simplify process management and customization. A new web-based customization experience is planned to replace the Process Template Editor, and a new work item form will be introduced with support for extensions and interactive elements.
  16. Extensions for Visual Studio Online, REST APIs for TFS 2015 RC, and more from Build 2015This post announces the early preview of a new extensibility model for Visual Studio Online (VSO) called extensions, enabling first-class, seamless connections between VSO and other tools and services, with integration points within the web experience such as context menus, toolbars, and new hubs. It also announces the availability of REST APIs for TFS 2015 RC, which can be called on both TFS and VSO, and the availability of service hooks in TFS 2015 RC for integration with various services. The MSDN API Sandbox is introduced as a tool for trying out VSO REST APIs with C# code samples.
  17. Scaled Agile Framework: Using TFS to support epics, release trains, and multiple backlogs whitepaperThis post announces the publication of a whitepaper detailing how to use Team Foundation Server (TFS) to support Scaled Agile Framework (SAFe) practices, specifically focusing on epics, release trains, and multiple backlogs. It explains that while TFS doesn't fully support all SAFe practices, it can implement many planning aspects. The whitepaper provides guidance on configuring and customizing TFS process templates (Scrum, Agile, CMMI) to enable SAFe support. It also notes that as of TFS 2015, out-of-box templates include these SAFe changes, making the previously downloadable SAFe-modified templates obsolete.
  18. Sample Chapter: “Scrum, Agile Practices, and Visual Studio” from the book “Adopting Agile Software Practices: From Backlog to Continuous Feedback, Edition 3”This post details how Visual Studio (VS) and Team Foundation Server (TFS) support software processes through three mechanisms: TFS capturing backlogs, workflow, status, and metrics; process templates defining workflows, reports, roles, and artifacts; and IDE client user experiences interacting with the server. It elaborates on the three standard process templates (Microsoft Visual Studio Scrum, MSF for Agile Software Development, MSF for CMMI Process Improvement) and the concept of teams within TFS, including role-based permissions. It also explains process cycles like releases and sprints, and the role of product backlogs and user stories, with a focus on how TFS tooling facilitates these practices.
  19. New TFS book soon available: Team Foundation Server 2013 CustomizationThis post details customizing TFS process templates, work items, and portfolios using raw XML files and TFS Power Tools, and enhancing web access usability with dashboard tiles and JavaScript plugins. It also covers creating custom controls for work items, server plugins, scheduled jobs, and build process customizations.
  20. Update your Overview and Progress reports to support the Portfolio backlogsThis post addresses a reporting issue in TFS 2010/2012 where Overview and Progress reports did not correctly display backlog items that were children of portfolio backlogs (Features). It provides updated reports for TFS 2013 and a PowerShell script to update existing team projects. The script uses the Team Foundation Server Object Model to re-apply reporting configurations for specified team projects and process templates. It also mentions the option to manually upload RDL files to the reporting server as an alternative to using the TFS Power Tools.
  21. Upgrade your 2012 team project from RTM to Update 2This post details the technical steps required to update existing Team Foundation Server (TFS) team projects from Visual Studio 2012 RTM to Visual Studio 2012 Update 2. It outlines specific modifications to process templates for Scrum, Agile, and CMMI methodologies. For Scrum, it details adding the 'Tags' column to the product backlog and adding missing transitions for 'Bug' and 'Product Backlog Item' (PBI) work items. For Agile, it covers adding the 'Tags' column, adding missing transitions for 'User Story', setting 'ResolvedBy' and 'ResolvedDate' fields in the 'Active -> Closed' transition, and updating reasons in 'Active -> New' and 'Active -> Closed' transitions. For CMMI, it details adding the 'Tags' column, setting 'ResolvedBy' and 'ResolvedDate' fields in the 'Active -> Closed' transition, and setting 'ActivatedBy', 'ActivatedDate', 'ResolvedBy', and 'ResolvedDate' fields in the 'Proposed -> Closed' transition. The post provides specific `witadmin` commands and XML snippets for exporting and importing process configurations and work item types, including modifications to the `ProductBacklog` section and `TRANSITIONS` and `FIELDS` elements within the `WORKFLOW` definition.
  22. Multivaluelist control in TFS Work Item TrackingIntroduced a multi-value control for work item fields in TFS, allowing users to select multiple values from a dropdown. This control has limitations regarding character limits and query capabilities due to its storage format. The post details the steps to enable this control by updating work item type definitions using witadmin or the process template editor, installing the control for TFS Web Access, and installing it on client machines running Visual Studio.
  23. Add bugs to the task board or backlog pagesThis post details the technical steps to configure Azure DevOps work item types (specifically bugs) to appear on either the task board or the product backlog. It involves exporting and modifying work item type definitions using `witadmin exportwitd` and `witadmin importwitd` to add fields like 'Activity' and 'Stack Rank' for task board integration, or 'Story Points' and 'Stack Rank' for backlog integration. It also covers exporting and modifying category definitions using `witadmin exportcategories` and `witadmin importcategories` to assign the 'Bug' work item type to either the 'Task Category' or the 'Requirements Category'.
  24. Visual Studio Update 2 Team Foundation Server feature -Work Item TaggingIntroduced work item tagging in Visual Studio Update 2 CTP, allowing for categorization and filtering of work items in backlog and work item query views in Team Web Access. This feature helps in identifying tasks by relevant keywords, cleaning up titles by removing prefixes, and expressing priority or status on work items. The post demonstrates how to apply tags, view them in column options, and filter the product backlog by tags.
  25. ALM Rangers ship the first version of Team Foundation Server Word Add-inThis post announces the release of version 1.0.12.0622 of the Team Foundation Server Word Add-in, developed by the ALM Rangers. The add-in allows users to import work items from a TFS Team Project and generate professional-looking Word documents from these work items. It links to the Codeplex project for more information and releases. Future plans include an Object Model based installation and bi-directional support for reading and writing to TFS.
  26. Team Foundation Service: Process template changesUpdated process template versions for Agile (6.1), CMMI (6.1), and Scrum (2.1). Implemented state model improvements for Agile User Stories, Scrum Product Backlog Items, and Bugs to allow transitions between any state. Fixed bugs in CMMI where ResolvedBy, ResolvedDate, ActivatedBy, and ActivatedDate fields were not set/cleared properly on some transitions. This addresses industry desire for less restrictive process flows, particularly highlighted by Kanban board usage.
  27. Changes to the Process Templates between VS 2012 Beta, RC and RTMDetails changes to process templates between VS 2012 Beta, RC, and RTM. From Beta to RC, the 'complexity' field was added back to the User Story work item type for prioritization, and the 'Assigned To' field was made required for Feedback Response in the Active state. For CMMI, the 'stack rank' field was added to the Requirement work item type. From RC to RTM, the 'Closed Date' field was made required for the Agile 'User Story' in the Closed state, and default text in the description field for User Story and Product Backlog Item was removed. The Scrum template added a transition from New to Committed for Bug and Product Backlog Item, and the 'Closed Date' field was added to the Task.
  28. Choosing the Right Tool for the Task to Manage Projects, Collaborate, and Monitor Progress in Visual Studio ALMThis post provides a roadmap for choosing the best Team Foundation client (Team Web Access, Team Explorer, Microsoft Test Manager, Microsoft Excel, Microsoft Project) for various project management, collaboration, and monitoring tasks in Visual Studio Team Foundation Server 2012. It details task support across different clients, including planning sprints, managing work items, requesting feedback, and reporting progress. It also highlights offline capabilities and licensing requirements.
  29. Work Item Field Attributes - What You Can and Can't ChangeThis post details the attributes of work item fields that can be changed, categorizing them into those changeable across a Team Project Collection (friendly name, AD sync, indexing, data type, reporting attributes) and those changeable for each Work Item Type (name on form, help text, allowed values). It also lists fields indexed by default and introduces the Work Item Field Explorer tool for examining non-changeable attributes. The post references `witadmin` commands and SDK topics for further details.
  30. Quick Response Sample – Command line utility to manage Team Foundation Server Teams and UsersDeveloped a command-line utility (TFSTeams.exe) to manage Team Foundation Server Teams and Users, addressing a feature gap for Hands-on Lab prerequisite setup automation. The utility leverages the Team service and Identity Management Service (IMS) in TFS, allowing for listing, creation of teams, and adding members. The sample code is based on using the Team service, which is an extension on top of the Identity Management Service (IMS) in TFS. The sample code is provided for reference, including TeamWrapper.cs.
  31. Deep Dive on Configure FeaturesThis post details the internal workings of the TFS 2012 upgrade wizard, explaining how it validates process templates against team project artifacts. It outlines the three validation steps: checking for existence in the process template, mapping to existing artifacts, and ensuring no conflicts. It also describes message severities (warning, error, critical error) and how they affect the upgrade process. Specific examples are provided for handling customized process templates, including logic for mapping fields like 'Effort' to 'OriginalEstimate' when 'Size' is not present, and mapping states like 'Proposed' when a direct match doesn't exist in certain work item types.
  32. How to Configure Features for dozens of team projectsThis post provides a C# console application that automates the configuration of features for multiple team projects in Team Foundation Server (TFS). It details the steps to create and run the application, including adding necessary assembly references and executing the code on the Application Tier. The application leverages the ProjectFeatureProvisioningService to iterate through team projects, validate process templates, and provision features if only one valid template is found. It also explains the underlying logic of the application, including how it determines if a project needs configuration and how it handles scenarios with zero or multiple valid process templates.
  33. How To: Associate automation programmaticallyThis post provides a C# code snippet to programmatically associate automation (e.g., unit tests, coded UI tests) with a test case in Azure DevOps. It details the use of the `ITestCase.Implementation` property and the `CreateTmiTestImplementation` method, which generates a GUID for the automation based on its name and requires the assembly name containing the test method. The code includes SHA1 hashing for GUID generation and a note on considering bulk saving for performance.
  34. Team Foundation Service December UpdateThis post announces a significant update to the hosted Team Foundation Service, introducing new functionality and improvements. Key updates include a redesigned navigation model for the web UI, richer homepages with team favorites and visualizations, a simplified user interface for single-team projects, and performance enhancements for Agile project management features. Email notifications have been enabled with new basic and advanced subscription management UIs. A 'Forecast Lines' feature has been added to the product backlog to project iteration boundaries based on team velocity. In-tile editing for 'assigned to' and 'remaining work' fields on the taskboard is now available.
  35. What's New in the Visual Studio Team Foundation Server 11 Developer PreviewThis post announces the Developer Preview of Visual Studio Team Foundation Server 11, detailing new features and enhancements across various areas including UI (Team Web Access, Team Explorer), Agile Project Management (Teams, Backlog, Task Board, Burndown Charts), Agile Requirements Management (PowerPoint Storyboarding, Microsoft Feedback Manager), Code Development (My Work, Pending Changes, Code Reviews), Version Control (Local workspaces, improved diff/merge), Build Definitions (Gated Check-ins, multi-framework test execution), Work Item Tracking (inline rich-text, customizable alerts, new work item types), and Administration (permissions, areas, iterations).
  36. Significant Changes Made to Streamline the Content for Work Item Type Schema ReferenceThis post details the streamlining of content for the Work Item Type Schema Reference. Changes include consolidating content to make syntax structure and attribute definitions for fields, workflow, and work item forms more accessible. Specific XML element reference topics like FIELD and Control have been updated. Schema files for defining work item types are now available for download from the Code Gallery, with instructions on how to use them with Visual Studio. The post also outlines a new TOC structure for defining work item fields, workflow, and forms.
  37. Use schemas to edit work item types and process templates for Visual Studio Team FoundationThis post announces the availability of schema files for work item types and process templates on Code Gallery. These schemas can be placed in the Visual Studio XML schemas folder to enable validation of work item type and process template files directly within Visual Studio.
  38. Using the Schemas to Edit Work Item Types and Process Templates for Team Foundation in Visual StudioThis post introduces the availability of Team Foundation schema files for process templates and work item types on Code Gallery. These schema files can be placed in Visual Studio's XML schemas directory to enable validation of work item type and process template files. This validation provides helpful hints for valid properties and child elements, and checks for valid strings, improving the developer experience by offering inline validation and error checking during the editing of these files.
  39. Enabling new Application Lifecycle Management Features for Visual Studio 2010 in Upgraded Team ProjectsThis post details the manual steps required to enable new Application Lifecycle Management (ALM) features in team projects that have been upgraded from earlier versions of Visual Studio Team System (e.g., VS 2008) to Visual Studio Ultimate 2010. It covers enabling Test Management, Agile Planning Workbooks, Agile/CMMI Dashboards and Reports, and updating existing reports to work with the new schema and data warehouse. It references specific blog posts by Chris Patterson, Aaron Bjork, and John Socha-Leialoha for detailed instructions and provides command-line examples for using the Team Foundation Power Tool (`tfpt addprojectportal`, `tfpt addprojectreports`).
  40. VS ALM Library Updates on MSDN for October 2010This post details updates to the Team Foundation SDK, specifically covering the server object model and the Microsoft.TeamFoundation.WorkItemTracking.Client namespace with a code snippet for connecting to a work item store. It also announces the removal of less valuable content from 'Extending Team Foundation' and 'Extending Work Item Tracking'. Additionally, it references updated MSDN Library topics for 'Getting Started With ALM', 'Installing Team Foundation Server' (including upgrade tips and SQL cluster support), and 'Testing the Application' (guidance for build, deploy, and test workflows, and creating hyperlinks to view test results from email). Lab Management documentation updates include information on moving System Center Virtual Machine Manager and enumerating operating systems for test agents in virtual environments.
  41. Sample Code: Create a Work Item in Team FoundationThis post provides a C# code sample demonstrating how to programmatically create a Work Item (specifically a User Story) in Team Foundation Server using the Work Item Tracking Object Model (WITOM). It details the steps involved: connecting to the TFS server, obtaining the WorkItemStore, selecting a team project, getting the desired WorkItemType, instantiating a new WorkItem, setting required fields (Title) and optional fields (Description), and finally saving the WorkItem. It also explains default field values and the necessity of setting the Title field.
  42. Sample Code: Refactoring to Handle Different Types of Work ItemsThis post provides sample code for interacting with Team Foundation Server (TFS) to retrieve and display work item hierarchies, specifically focusing on 'User Story' work items and their estimates. It demonstrates how to connect to TFS, query for work item links, and recursively print the tree structure. The samples are refactored to handle customizations in work item types and estimation fields, including using XML configuration to specify estimation fields per project. It also shows how to use work item categories to generalize for different work item types like 'Requirements'.
  43. Managing Reference Data in Visual Studio Team Edition for Database ProfessionalsThis post details methods for managing reference data in Visual Studio Team Edition for Database Professionals, specifically addressing limitations of the original Data Bound Generator. It proposes using post-deployment scripts (ReferenceData.sql) and highlights the upcoming Sequential Data Bound Generator as better alternatives for populating reference tables in development and test databases.
  44. Custom Controls in Work Item TypesThis post introduces the Work Item Tracking Custom Controls mechanism for Team Foundation Server, allowing for enhanced UI capabilities, event-based rules, and workflow extensions within Work Items. It details the purpose, restrictions, implementation rules (deriving from System.Windows.Forms.Control, implementing IWorkItemControl), and how to define custom controls in Work Item Type definitions using the 'Type' attribute. It also explains the role of Work Item Custom Control (.wicc) manifest files for locating and loading custom control assemblies.
  45. Answer to an e-mail comment concerning policies for work item typesThis post details how to enforce policies on work items in VSTS Workgroup Edition. It explains that project administrators can update any work item if they are members of the Team Foundation Administrators group or the Contributors group, requiring the 'Edit work items in this node' permission. It also describes how to restrict state changes to specific users or groups by customizing the work item type and using 'Transition Security'. Furthermore, it explains how to restrict state changes based on other field states by indicating a field as required within a specific state definition in the work item type customization.
  46. Process Planning GuideThis post details the concept of process templates in Team Foundation Server, explaining how they define key aspects of a team project such as security groups, source control settings, work item types, queries, reports, project areas, iterations, and process guidance. It outlines the process of customizing process templates and team projects, and provides considerations for setting up Team Foundation Servers and creating team projects, including planning with stakeholders and determining the appropriate process template.
  47. Setting Permissions in Team FoundationThis post details the initial setup of permissions for Visual Studio Team System Beta 2, outlining roles such as Team Foundation Server Administrator, Team Project Lead, and Team Project Contributor. It specifies the required group memberships and provides step-by-step instructions for configuring these permissions across various components like Windows groups, Team Foundation Server groups, Windows SharePoint Services, and Reporting Services. It also includes a caution against modifying the TFS Everyone group.