TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Azure DevOps Process Customization

19 posts · Jun 2005 – Oct 2023

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 general availability of moving projects from a Hosted XML process to an Inherited process, allowing for the adoption of the modern inherited process model. This migration involves cloning the Hosted XML process, configuring and verifying the new inherited process, and then changing the project to use it. The process is irreversible and requires thorough testing with a test project before migrating live projects.

All Microsoft trails
  1. Seamless Automation: Bridging Requirement Discussion Transcripts to Azure DevOps FeaturesThis post introduces an end-to-end automation process for generating Azure DevOps features from requirement discussion transcripts. It details a structured folder system for managing historical data, custom skills (using Semantic Kernel), and project information. The process involves breaking down large transcripts, identifying requirements using semantic functions, refining features, and importing them into Azure DevOps. It leverages Python, Semantic Kernel, and Azure DevOps libraries, with a provided Jupyter Notebook and GitHub repository for implementation.
  2. How to hide or edit the reason field in Azure DevOpsThis post provides two distinct workarounds for customizing the 'Reason' field in Azure DevOps work items. The first workaround details the use of REST APIs to hide the system 'Reason' field from the work item form. The second workaround explains how to create a custom picklist field to replace the system 'Reason' field and then uses the Cascading Picklist extension to dynamically control the values displayed based on the work item's state.
  3. Azure DevOps Roadmap update for 2019 Q4This post details planned Q4 2019 roadmap updates for Azure DevOps services. Key contributions include: Azure Boards: Automatic state change for parent work items based on child work item state changes. Azure Repos: Modern, fast, mobile-friendly UI for landing pages, pull request details, commit details, and branch compare. Azure Pipelines: General availability of multi-stage pipelines UX with improvements to logs and navigation, and parity with classic pipelines features like skipping stages. Auditing enhancements include public preview of streaming for SIEM tools (Splunk, Azure Log Analytics, Azure Event Grid), expanded audit events for pipelines and releases, and auditing for Azure Artifacts (permission changes, feed, upstream, package operations). Pipeline Artifacts and Pipeline Caching are reaching General Availability. Azure Artifacts: Public feeds GA and project-scoped feed creation UX. Reporting: Rollup on Kanban cards, advanced Sprint Burndown widget configuration (Story Points, Task count, custom fields), creation of dashboards without a team, and copying dashboards. Administration: Opt-in to multi-organization billing.
  4. What’s new in Azure DevOps Sprint 154This post introduces several new features for Azure DevOps: linking GitHub releases as artifact sources in release pipelines, creating and embedding work items (features and user stories) directly from wiki pages, instant search for work items with recently accessed lists and full search syntax support, live updates for work items without manual refresh, and the ability to view parent work item information as a configurable column in the backlog. These features aim to improve workflow efficiency and reduce context switching.
  5. What’s new in Azure DevOps Sprint 153Sprint 153 introduces the ability to embed queries with a tree of work items in a wiki page, allowing for hierarchical display of Epics, Features, Tasks, and User Stories. It also enhances work item copying by including attachments and provides GitHub annotations on the Kanban board for quick linking to commits, pull requests, or issues. A Top Publisher program is launched in the Marketplace to build confidence in Azure DevOps extensions.
  7. Edit and Delete Discussion Comments on the Work ItemIntroduced the ability to edit and delete comments within the discussion section of Azure Boards work items. The UI has been updated with comment bubbles and larger avatars. Edited comments are marked with an '(edited)' watermark, and deleted comments are logged in the work item's history tab for auditability.
  8. New Basic Process Available in Azure DevOpsIntroduced a new 'Basic' process for Azure DevOps to simplify work item tracking for new users. This process reduces the number of work item types to Epic, Issue, and Task, and simplifies the state model to 'To Do', 'Doing', and 'Done'. The hierarchy is also simplified to two levels: Issues can be broken down into Tasks, with an optional Epic work item type for grouping issues. Core fields required for functionality like sprint burndown and capacity planning are retained, while extraneous fields are removed.
  9. Azure DevOps Server 2019 RC2 now availableThis post announces the release of Azure DevOps Server 2019 RC2, which includes new features such as integration with GitHub Enterprise for linking commits and pull requests to Azure Boards work items, the ability to configure builds using YAML (Configuration as Code), and support for draft pull requests to manage work in progress. It also mentions that this is the last planned prerelease before the final release of Azure DevOps Server 2019.
  10. Announcing new REST API's for Process CustomizationIntroduced new REST API endpoints for process customization in Azure DevOps. For the Inheritance model, these APIs allow programmatic creation and management of work item types, pages, groups, fields, states, and rules. For Hosted XML processes, APIs are available for checking existence, importing, and exporting. The APIs are available in version 5.0 (preview) of the REST API, combining previous inherited model APIs under a single domain. Client libraries (version 16.139.0-preview) and sample code on GitHub are also provided.
  11. Moving from Hosted XML Process to Inherited Process - Generally AvailableThis post announces the general availability of the feature to move projects from a Hosted XML process to an Inherited process in Azure DevOps. It outlines the three-step migration process: cloning the Hosted XML process to an inherited one, configuring and verifying the new inherited process (including manual addition of unsupported customizations), and finally changing the project to use the new inherited process. It emphasizes the irreversibility of the migration and the critical need for testing with a test project before migrating production projects. It also provides links to relevant documentation for each step.
  12. Moving from Hosted XML process to Inheritance process - Private PreviewThis post announces and details the steps for a private preview of migrating Azure DevOps projects from the Hosted XML process model to the Inheritance process model. It outlines a three-step process: 1. Move the Hosted XML process to an inherited process (cloning customizations). 2. Configure and verify the new inherited process, manually adding unsupported customizations. 3. Move the project to use the new inherited process. It emphasizes the importance of testing with a test project before migrating production projects, as the migration is irreversible. Feedback is solicited via email.
  13. What’s new in VSTS Sprint 135 UpdateThis post introduces richer, graphical release progress views in Azure Pipelines, presenting artifacts, environments, and deployment status more visually. It also announces the open-sourcing of a process migrator tool on GitHub to facilitate the import/export of inherited process customizations, enabling safer refinement of these customizations in a separate VSTS account before applying them to production.
  14. Work Item Type and Inclusive DesignThis post details the motivation and design process behind replacing work item type color bars with icons in Azure DevOps. It explains the accessibility problem with color-only indicators, especially in high contrast modes, and outlines the criteria for the new design: recognizable, minimalist, built-in, and flexible. It discusses rejected iterations like using work item type strings and abstract shapes, and highlights the iterative process of refining the icon design based on user feedback, including the redesign of the bug icon.
  15. Handling a TFS 2018 Upgrade from Old Form to New FormThis post announces the deprecation of the old work item form's `<Layout>` tag in TFS 2017.2 and its removal in TFS 2018. It outlines the mandatory upgrade process which will transform work item type definitions to use the `<WebLayout>` element and remove legacy custom controls. It provides a three-step process for users to refine their templates in a pre-production environment, export them, and upload them post-upgrade. For legacy custom controls built by Microsoft, it directs users to the VSTS Marketplace for new controls and advises converting other custom controls to the new REST-based extensibility model using the Work Item Form Service.
  16. Mobile work item form general availabilityThis post announces the general availability of the mobile work item form and the mobile 'My work items' page in Visual Studio Team Services. It highlights improvements to the work item form, including enhanced discussion experience with Markdown support and a preview of the latest comments. It also introduces a mobile version of the personalized account homepage, which lists projects, pull requests, and work items, with a focus on the 'My work items' tab showing followed, assigned, and recently visited/modified items. Mobile navigation controls are also added to allow users to move between different parts of VSTS and return to the full desktop site.
  17. Team Services Process Customization Roadmap (Jan 2017)This post outlines the roadmap for Azure DevOps process customization for the Inheritance process model, detailing planned features for Q1 and Q2 2017. These include custom backlog levels, improved navigation for process customization, defining business rules for work item types, adding identity fields, and REST API support for customization. It also compares the Inheritance, Hosted XML, and On-premises XML process models and mentions future plans for bringing the Inheritance model to on-premises.
  18. The mobile work item form (preview)Introduced a preview of the mobile work item form for Visual Studio Team Services, optimizing work item display and editing on mobile devices. The form supports mobile-friendly controls for common actions like changing state, updating area paths, adding attachments, and managing tags. It also integrates with email and Microsoft Teams notifications for immediate action on work items.
  19. New work item form in TFS 2017This post announces the release of the new work item form in TFS 2017, which was previously available in Visual Studio Team Services. It details how to enable and configure the new form in TFS 2017, including opt-in experiences for existing collections and staged rollouts. The post also breaks down the anatomy of the new form, explaining the system header, pages, sections, groups, and controls, and highlights the simplified XML layout for customization and the improved extensibility model for adding custom pages, groups, and controls.
  20. Custom work item types on Team ServicesThis post introduces the capability to create custom work item types (WITs) in Team Services. It details the process of creating an inherited process, adding a new WIT with a name, description, and color, customizing its form layout and fields, and modifying its default states. It also explains how to add custom WITs to backlog and board levels and how to destroy custom WITs. The post notes that renaming a WIT is not currently possible but descriptions and colors can be updated later. It also mentions existing limitations for states in the completed category and that the feature was rolling out across Team Services.
  21. Work items now open in the web from Visual Studio '15'This post announces the change in Visual Studio '15' where work items now open in a browser window instead of the Visual Studio client. This shift aims to provide a unified work item experience across all platforms, allowing extensions to be written once and function across clients. It highlights recent web feature additions such as improved discussions with @mentions and #mentions, development and related work controls, the ability to follow work item changes, checkbox controls, and data density improvements. It also mentions future plans for additional custom controls, redesigned history and attachments experiences, and improved mobile views. The post also details the migration of VS extension templating features to the web, the upcoming Excel integration for queries and backlogs, and general performance and navigation improvements. A setting is provided to revert to the legacy form for a transition period.
  22. VSTS Process Customization futures (June 2016)This post outlines future plans for Azure DevOps process customization, detailing planned features for Q3 and Q4 2016. Key planned features include the ability to create custom work item types and add them to the backlog, the addition of identity fields to existing work item types, the definition of simple business logic and rules through a UI, the release of REST APIs for customization, and improvements to custom states and picklists. Early mocks and a rough timeline are provided for these upcoming capabilities.
  23. States customization on Team ServicesThis post details the initial release of states customization for inherited work item types in Team Services. It describes how to add new states via the process administration page, specifying name, state category, and color. It also covers removing custom states and hiding inherited states, explaining their impact on work item visibility and validity. The concept of state categories (Proposed, In Progress, Resolved, Completed, Removed) is introduced to support backlog and board functionality. Future planned features include state ordering, automatic tracking of transition fields, and transition restrictions.
  24. Boolean (checkbox) fields on Team ServicesIntroduced the ability to add a Boolean (checkbox) field to work item types in Team Services. Detailed the technical challenges in handling the tri-state nature of Booleans (NULL vs. False) and the decision to treat NULL and False values the same in work item and query experiences. Described the field definition, including the sparseness of the Options tab and the default value being False. Outlined the client-specific user experiences for Boolean fields across Web access, Eclipse TEE, various Visual Studio versions, and Excel. Explained the behavior of Boolean fields on existing work items, where un-updated items are treated as False for querying.
  25. Merging the concepts of Account and CollectionThis post announces the merging of Account and Collection concepts in Visual Studio Team Services (VSTS) in preparation for the introduction of 'Organizations'. This change removes 'DefaultCollection' from URLs and merges Control Panel settings with Collection settings. Existing links, tools, and connections will be fully supported. The change will roll out for newly created accounts in early April and for all existing accounts in late April.
  26. VSTS Process Customization futures (January 2016)This post outlines the future roadmap for Azure DevOps process customization, detailing planned features for Q1 and Q2 2016. It announces the completion of adding custom fields (HTML, multi-line string, Boolean) and modifying state workflows. Planned features include adding picklist and identity fields, creation of custom work item types, defining business logic and rules via a UI, REST API support for customization, and import/export of custom processes. Mockups illustrate the planned UI for these features.
  27. VSTS New work item form futures (January 2016)This post details the completion of several features for the new work item form in Visual Studio Team Services: developer workflows (linking branches, pull requests, and commits), header improvements (increased data density, grouping reason and state), sticky behavior in groups (remembering collapsed states), links in the front page (new customizable control for displaying link relationships), admin layout improvements (increased UI fidelity, bringing discussion and development group into admin layout, allowing HTML fields), and new control extensibility (enabling user-developed controls via a new contribution point).
  28. How we plan to enable creating Multiple Collections per AccountThis post details the planned evolution of Visual Studio Team Services (VSTS) account structure to better support large, geo-distributed organizations. It announces the shift from the current Account/Collection model to a new 'Organization' concept. Organizations will logically group multiple 'Accounts' (which will merge with the existing 'Collection' concept), allowing for datacenter-agnostic grouping. Key changes include merging Account and Collection into a single entity, introducing the Organization concept, supporting licenses across all accounts within an organization, and enabling organization-level security policy application.
  29. Release Management Workflow MigratorIntroduced an open-source migration tool and guidance to export Release Management agent-based deployment pipelines for reuse in the Release Management service in Visual Studio Team Services (VSTS). The tool aims to help users with complex agent-based workflows transition to the new RM service with minimal rewriting, focusing on the 'from' aspect of migration rather than the 'to'.
  30. Process Template changes to TFS 2015 RTMThis post details updates to TFS 2015 process templates, including the addition of an 'Epic' portfolio level, modifications to workflow states and fields for work items (bugs, tasks), and the introduction of new fields like Priority and StateChangeDate. It also notes that system templates are now locked and cannot be changed, and introduces Process Inheritance for automatic updates.
  31. Test result data retention with Team Foundation Server 2015This post introduces new test result retention features in TFS 2015 Update 1. It enables team project level policies to clean up all test result data (runs, results, attachments) based on age, with separate limits for automated and manual test results. It also integrates test result retention with the new Build vNext system, allowing test results to be deleted when builds are deleted. This addresses the previous lack of in-product support for test result cleanup and the limitations of the Test Attachment Cleaner Power Tool.
  32. Visual Studio Online Process Customization - UpdateThis post details the prioritized scenarios for Azure DevOps process customization, including adding custom fields with metadata (tooltip, default value, required status), a WYSIWYG layout editor for controlling field appearance on work item forms, and the concept of inherited processes. Inherited processes allow customization while automatically inheriting changes from parent processes, and existing projects can be migrated to use them. The functionality is described as being a couple sprints away from deployment.
  33. Scaled Agile Framework: Visual Studio Online process template updatesThis post announces the integration of Scaled Agile Framework (SAFe) concepts into Azure DevOps Online's Agile, Scrum, and CMMI process templates. Key additions include an 'Epic' work item type with associated backlog and board functionality, and a 'Value Area' field (Business/Architectural) for Epics, Features, and Stories. These changes are opt-in and will be included by default in the on-premises TFS 2015 RTM release.
  34. Visual Studio Online Process CustomizationThis post announces upcoming features for Visual Studio Online (VSO) process customization, including private preview for migrating on-premises TFS process templates, a 'shared process' model for inheritance rather than copying, 'inherited process' for lightweight customization of out-of-the-box templates, a web-based replacement for the Process Template Editor, and a new work item form with extension support and improved interactivity. It outlines a phased delivery of these features, starting with custom fields and progressing to new work item types.
  35. Changes in creating VSO Environments in Visual Studio IDEThis post announces a shift in how environments are managed within Visual Studio Online (VSO) and Azure DevOps. Previously, developers could create and manage environments directly within the Visual Studio IDE, provisioning Azure Resource Groups and registering them as VSO Environments. This functionality is being moved to the Team Web Access (now Azure DevOps portal). The new workflow emphasizes deploying directly to Azure Resource Groups and managing environments via the Azure portal. The "Deploy to environment" feature in the VS IDE is being deprecated in favor of "Deploy to Resource Group." The Environments hub in Team Explorer is also being retired, directing users to the Azure portal for environment management. This change aims to provide a more consistent experience across cloud providers and ALM tools.
  36. Scaled Agile Framework: Using TFS to support epics, release trains, and multiple backlogs whitepaperThis post introduces a whitepaper detailing how Team Foundation Server (TFS) can be used to implement planning practices of the Scaled Agile Framework (SAFe), including support for epics, release trains, and multiple backlogs. It provides guidance on configuring and customizing TFS process templates (Scrum, Agile, CMMI) to enable SAFe practices with minimal changes. Downloadable SAFe-modified process templates are provided, with a note that out-of-the-box templates for TFS 2015 and later include these changes.
  37. Work-items tracking using Release ManagementThis post introduces the 'Change Summary' feature in Microsoft Release Management 2013 Update 3 RC/RTM. This feature provides a tab on the Release page that displays a list of work-items that are new or changed in the current release relative to the last successful release. It shows Id, Type, Title, Owner, and State of the work-items, with links to view individual work-items on TFS. The feature also provides a Change Summary view in the Release Explorer for automated releases. Limitations include availability only in vNext deployment pipelines, TFVC source control requirement, and specific handling of work-items across branches and external builds.
  38. Where is the field on the work item form to order the backlog?This post announces the removal of the Stack Rank/Backlog Priority field from the work item form in Visual Studio Online to reduce user confusion, while maintaining its backend functionality for backlog ordering. It introduces context menu items for changing backlog item positions as an alternative to drag-and-drop. It also provides guidance on how to re-add the field to the form via process template customization for on-premises installations.
  39. Test Plan and Test Suite Customization with TFS2013 Update3This post details the addition of custom field and workflow customization for Test Plan and Test Suite artifacts in TFS 2013 Update 3. It explains how to align these artifacts with organizational business processes by changing default states, adding user fields (e.g., reviewers, approvers), and custom fields (e.g., Test Type). The post also describes the enhanced permissions model, including the new 'Manage test suites' permission, and how work item history is used to track changes to test plans and test suites.
  40. 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 agile software development processes. It explains the role of TFS in capturing backlogs, workflow, status, and metrics for transparency. It also describes process templates (Microsoft Visual Studio Scrum, MSF for Agile Software Development, MSF for CMMI Process Improvement) that define work item types, reports, roles, and artifacts. The post outlines Scrum roles (Product Owner, Team of Developers, Scrum Master) and how TFS supports team structure with home pages, product backlogs, and task boards. It also discusses permission enforcement mechanisms and the iterative nature of software projects through releases and sprints, including the use of Planning Poker for estimation and the capture of acceptance tests as test cases in TFS.
  41. New TFS book soon available: Team Foundation Server 2013 CustomizationThis post announces a new book, 'Team Foundation Server 2013 Customization,' by Gordon Beeming. The book covers extensive customization of TFS 2013, including customizing process templates (work items, portfolio backlogs, categories), enhancing web access usability (dashboards, column defaults, JavaScript plugins), creating custom controls for work items (Windows Forms and Web Access), developing server plugins (check-in, work item changed), creating scheduled jobs, and customizing build processes with custom activities and arguments. It details practical steps for adding fields, altering workflows, creating new work item types, and debugging custom code.
  42. Cloning test plans using Microsoft Test ManagerIntroduced the capability to clone test plans and test suites within Microsoft Test Manager (MTM) via the user interface in Visual Studio Update 2. This feature allows for the replication of test cases, shared steps, requirements, suite structure, and plan properties (excluding test results and bugs) to facilitate test management across sprints or releases. The cloning process can be initiated from the test plan properties page, Test Plan Manager, or by right-clicking the root node in the Contents view. Users can select specific suites to clone and optionally clone associated requirement work items. The destination test plan can be named, and its area and iteration paths specified. Cloned work items include a comment in their history referencing the clone operation ID and source work item ID for auditing.
  43. Upgrade your 2012 team project from RTM to Update 2This post provides detailed, step-by-step instructions for on-premises TFS users to manually update their existing team projects to incorporate the process template improvements introduced in Visual Studio 2012 Update 2. It covers modifications for Scrum, Agile, and CMMI process templates, including exporting and importing process configurations and work item types using the `witadmin` tool to add the 'Tags' column and define missing transitions and field values for work items like Product Backlog Items, Bugs, and User Stories.
  44. Multivaluelist control in TFS Work Item TrackingThis post introduces a custom control for multi-value selection in TFS Work Item Tracking. It details how to modify work item type definitions (e.g., 'Bug') to include a new string field (e.g., 'OS') with suggested values. It then explains how to use the `MultiValueControl` within the work item form. The post provides instructions for installing the control on TFS Web Access and for individual Visual Studio clients, including downloading the control from CodePlex and enabling it via the Extensions page. It also highlights the limitations of the custom control, such as character limits and restricted query/reporting capabilities due to the storage format, and suggests using Tags as an alternative.
  45. Visual Studio Update 2 Team Foundation Server feature -Work Item TaggingThis post introduces and demonstrates the practical application of 'Work Item Tagging' in Team Foundation Server (TFS) as part of the Visual Studio Update 2 CTP. It explains how tags can replace keyword prefixes in work item titles for cleaner presentation and improved identification. The post illustrates how to add multiple relevant keywords to a work item, filter work items in backlog and query views using these tags, and shows the audit history of tag additions and removals. It also provides instructions on how to add tags to work items and configure 'Tags' as a column in query results.
  46. TFS/Agile PM: Configuring so your tasks are estimated in story pointsThis post details how to customize the unit of measurement for the 'Remaining Work' field on Task work items in Team Foundation Server (TFS) 2012. It provides a step-by-step guide using `witadmin.exe` to export, edit, and import the common process configuration XML file. Specifically, it shows how to change the `format` attribute of the `TypeField` element for `Microsoft.VSTS.Scheduling.RemainingWork` to use custom suffixes like 'sp' for story points.
  47. Changes to the Process Templates between VS 2012 Beta, RC and RTMThis post details specific changes made to Azure DevOps process templates between Visual Studio 2012 Beta, Release Candidate (RC), and Release to Manufacturing (RTM). Key changes include: **Beta to RC:** - Added 'stack rank' field to User Story (Agile) and Requirement (CMMI) work item types. - Added 'backlog priority' field to Bug and Product Backlog Item (Scrum) work item types. - Made 'Assigned To' field required for 'Feedback Response' work items in all templates. **RC to RTM:** - Added 'Closed Date' field to Task work items in the Scrum template, including logic for setting it in correct states and transitions. - Removed default text from description fields for User Story (Agile) and Product Backlog Item (Scrum) work items. - Added state transitions: New to Resolved for User Story (Agile), and New to Committed for Bug and Product Backlog Item (Scrum).
  48. Work Item Field Attributes - What You Can and Can't ChangeThis post details the attributes of work item fields that can be changed across a Team Project Collection (Friendly name, Synchronization with Active Directory, Indexing, Data type for PlainText/HTML, and Reporting attributes) and those that can be changed for each Work Item Type (Name on form, Help text, Allowed values). It also lists fields indexed out-of-the-box and describes non-changeable/hidden attributes using the Work Item Field Explorer tool, linking to SDK references for each attribute.
  49. Deep Dive on Configure FeaturesThis post details the validation logic and steps within the TFS 2012 upgrade wizard. It breaks down the wizard's actions (adding work item types, categories, tabs, actions, and configuration settings) and their dependencies on process template artifacts. It elaborates on three key validation steps: checking for artifact existence in the process template, verifying if artifacts can be mapped to existing team project artifacts, and ensuring no conflicts arise with existing team project artifacts. Specific examples of validation rules and exceptions for localized and customized process templates are provided, along with an explanation of message severities (warning, error, critical error) and their impact on the upgrade process.
  50. How to Configure Features for dozens of team projectsThis post provides a programmatic solution to automate the 'Configure Features' wizard for Team Foundation Server (TFS) 2012. It outlines the steps to create a C# console application that interacts with TFS services to provision features for multiple team projects, addressing the inefficiency of using the wizard manually for dozens of projects. The solution involves referencing specific TFS assemblies, obtaining a Team Foundation Request Context, and utilizing the ProjectFeatureProvisioningService to validate process templates and provision features.
  51. Changing the default number of tasks displayed on the taskboardThis post addresses an issue where the default taskboard display limit of 500 tasks in Azure DevOps (then Team Foundation Service) could be exceeded, causing the taskboard to appear broken. It provides a solution for self-hosted servers by modifying the process template using the `witadmin` tool to increase the `workItemCountLimit` within the `<IterationBacklog>` element of the Agile process configuration. For hosted services, the only simple option is to delete tasks. The post also warns about increased memory demand on clients when increasing the limit.
  52. Significant Changes Made to Streamline the Content for Work Item Type Schema ReferenceThis post details significant content consolidation and rework for the Work Item Type Schema Reference in Team Foundation Server (TFS). It explains the consolidation of syntax structure and attribute definitions for elements supporting fields, workflow, and work item forms. Specific XML element reference topics like FIELD and Control are kept and updated. Many element definition and all schema definition topics are eliminated. New TOC structure is introduced for Defining Work Item Fields, Defining and Customizing Work Item Workflow, and Designing and Customizing a Work Item Form. Schema files are made available for download. The post also previews upcoming updates to the Process Template Schema Reference.
  53. Use schemas to edit work item types and process templates for Visual Studio Team FoundationThis post introduces the availability of schema files for work item types and process templates on Code Gallery. By dropping these schema files into the 'Program FilesMicrosoft Visual Studio 10.0XmlSchemas' folder, Visual Studio will validate work item type or process template files against the appropriate schema, improving the accuracy and consistency of process definitions.
  54. Using the Schemas to Edit Work Item Types and Process Templates for Team Foundation in Visual StudioThis post introduces the availability of schema files for Team Foundation process templates and work item types. These schemas can be placed in Visual Studio's XML schema directory to enable validation of work item type and process template files. Visual Studio will then provide helpful hints during editing, such as valid properties, child elements, and refnames, and will flag missing required properties or invalid strings, improving the accuracy and correctness of customizations.
  55. Sample Code: Create a Work Item in Team FoundationThis post provides sample code demonstrating how to programmatically create a Work Item (specifically a User Story) in Team Foundation Server using the Microsoft.TeamFoundation.Client and Microsoft.TeamFoundation.WorkItemTracking.Client assemblies. It outlines the steps to connect to the TFS server, obtain a WorkItemStore, get a specific Project and WorkItemType, instantiate a new WorkItem, set required fields like 'Title' and optional fields like 'Description', and then save the WorkItem.
  56. Answer to an e-mail comment concerning policies for work item typesThis post addresses specific work item policy enforcement scenarios: Project Administrator edit permissions, restricting 'Resolved' state changes to the assigned person, and requiring specific fields (like 'Planned Hours') before marking a work item as 'Resolved'. It explains that these policies are achievable through customization of work item types and points to relevant documentation for 'Transition Security' and the use of `<REQUIRED />` tags within state definitions.
  57. Process Planning GuideThis post details the structure and components of process templates in Team Foundation Server, explaining how they define security groups, source control settings, work item types, reports, work products, project areas, iterations, and process guidance. It outlines the scenarios for customizing process templates versus customizing individual team projects and provides considerations for setting up Team Foundation Servers and creating new team projects, emphasizing the importance of stakeholder involvement and process template selection.