TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Azure DevOps Pipelines for Dev-to-Prod Promotion

40 posts · Nov 2013 – Aug 2025

What this trail covers

Azure Pipelines continues to evolve its release definition editor, introducing a pipeline view for visualizing deployment progression across environments. This includes in-context configuration for approvals, environment settings, and deployment properties. The editor also features improved task and phase editing, centralized variable management, and the application of deployment templates. This enhances the user experience for managing complex release workflows and promotes consistency through. This post introduces a preview of the Continuous Delivery feature for App Services in the Azure portal, simplifying the setup of a robust deployment pipeline that builds, runs tests, and deploys to staging and production for every code commit. It supports VSTS and GitHub as source repositories and ASP.NET/ASP.NET Core applications, with options for load testing and staging environments.

All Microsoft trails
  1. Azure Developer CLI: From Dev to Prod with Azure DevOps PipelinesIntroduced a multi-stage Azure DevOps YAML pipeline for implementing a 'build once, deploy everywhere' pattern using the Azure Developer CLI (azd). This includes stages for building and packaging, deploying to development, and promoting to production. The post details the use of pipeline artifacts for storing and retrieving build packages across jobs, replacing older file backup methods. It provides specific YAML snippets for installing azd, configuring authentication, packaging the application, provisioning infrastructure, and deploying to different environments. The post also covers setup steps for users, including project initialization, environment configuration, and pipeline setup via `azd pipeline config`.
  2. Azure Developer CLI: From Dev to Prod with One ClickThis post enhances the 'Azure DevOps Pipelines for Dev-to-Prod Promotion' feature by detailing the implementation of a 'build once, deploy everywhere' pattern using Azure Developer CLI (azd). It introduces conditional Bicep deployment driven by environment variables (`AZURE_ENV_TYPE`), environment-specific infrastructure provisioning (networking, storage, app service plan), and an updated CI/CD workflow that utilizes GitHub Action Artifacts for packaging and promoting the application from dev to prod using the same build artifacts. It also provides step-by-step instructions for initializing the project, setting up dev and prod environments, and configuring the CI/CD pipeline.
  3. February Patches for Azure DevOps ServerThis post releases Patch 3 for Azure DevOps Server 2022.2, which specifically addresses an issue causing YAML pipelines to fail after the installation of the previous version of Patch 3. It also provides instructions on how to verify the installation of the patch.
  4. Revolutionizing Requirement Gathering: Azure DevOps Meets Azure OpenAI using Semantic kernelIntroduced a method to leverage Azure OpenAI and Semantic Kernel to programmatically generate Azure DevOps work items (Features) from natural language input. This involves defining semantic functions for feature description generation and native functions for Azure DevOps API interaction. Demonstrated the use of Sequential Planner for dynamic work item creation.
  5. Deploy a Java application to Azure App Service using GitHub ActionsThis post details the integration of a Java Spring Boot application with Azure App Configuration for feature flag management. It demonstrates how to dynamically enable or disable features (represented by a mascot named 'Bit') through the Azure portal, showcasing the use of feature flags for controlling application behavior, enabling A/B testing, and facilitating blue-green deployments. The post also touches upon targeting specific geographical areas, users, or groups, and setting time windows for feature visibility.
  7. Things to consider when running visual tests in CI/CD pipelines: Getting Started (Part 1)This post details setting up build server environments for running visual tests in CI/CD pipelines. It covers configuring headless Chrome on Ubuntu (16.04 and 18.04) by installing Chromium and provides commands for Java 13 and Maven installation. It also presents a Java code example demonstrating how to handle different execution environments (local, pipeline, container) using environment variables and integrates with Applitools for visual testing by capturing batch names and IDs from environment variables.
  8. Let's Hack a Pipeline: Argument InjectionThis post details the security vulnerability of argument injection in Azure Pipelines when using queue-time variables with script steps. It demonstrates how an attacker can inject malicious commands by manipulating variable values. The post then presents two mitigation strategies: using runtime parameters with defined values and using tool-specific tasks that properly escape inputs. It also provides links to the second and third episodes in the series, focusing on pipeline stealing and shared infrastructure security.
  9. Create and manage Azure Pipelines from the command lineIntroduced the `az pipelines` command group in the Azure DevOps extension for the Azure CLI, enabling users to create, delete, list, run, show, and update YAML-backed Azure Pipelines from the command line. It provides an interactive flow for pipeline creation and the ability to automate the process by referencing a YAML file. Additionally, it covers managing pipeline runs, artifacts, and tags using `az pipelines runs` commands.
  10. Azure DevOps Server 2019 RC2 now availableThis post announces the release of Azure DevOps Server 2019 RC2, highlighting new features such as the integration of GitHub Enterprise commits and pull requests with Azure Boards work items, the ability to configure builds using YAML (Configuration as Code), and the introduction of draft pull requests to prevent premature completion. It also provides links to download the RC2 ISO and web installer, as well as the release notes.
  11. Azure DevOps Projects general availabilityAnnounces the general availability of Azure DevOps Projects, which simplifies the setup of Azure resources, Git repositories, CI/CD pipelines, and Application Insights for deploying applications to various Azure services. It also highlights expanded deployment targets (AKS, Service Fabric Mesh, VMs, Azure SQL Database) and language support (Ruby, Go).
  12. Azure DevOps Project: New feature additionsThis post announces new deployment targets for Azure DevOps Projects, including Azure Virtual Machines (using Deployment Groups), Azure Kubernetes Service (AKS) with Helm Charts and Azure Container Registry integration, Service Fabric, and Azure SQL Databases. It also adds support for Ruby and Go application frameworks to Azure App Services. The underlying VSTS build and release pipelines are leveraged for these new targets.
  13. What’s new in VSTS Sprint 133 UpdateThis post introduces Helm tasks for packaging and deploying Helm charts to Azure Container Service (AKS) or any other Kubernetes cluster. It also adds better support for Azure Database for MySQL and Ruby on Rails. YAML builds are now out of preview, allowing users to maintain specific branches for triggering CI builds directly within the YAML file.
  14. What’s new in VSTS Sprint 132 UpdateThis post introduces build completion triggers, allowing related builds to be chained together so that changes to an upstream component can trigger a rebuild of a downstream dependency. It also generally releases Deployment Groups, a feature for orchestrating deployments across multiple machines (on-premises or cloud) with rolling updates and high availability. New release definition templates and an Azure Resource Group task are also mentioned to simplify setup. Finally, it highlights the ability to add commit messages from each commit into the pull request description with one click.
  15. Announcing "Azure DevOps Project" public previewAnnounces the public preview of Azure DevOps Project, a new offering that simplifies the setup of an application on Azure with a full DevOps pipeline. It provisions Azure resources, a Git code repository with a sample application, Application Insights, and a continuous delivery pipeline. The project dashboard provides a single view for monitoring code commits, builds, and deployments. It supports various frameworks (.NET, Java, PHP, Node, Python) and integrates with Visual Studio Team Services (VSTS) for CI/CD.
  16. Pipeline as code (YAML) previewThis post previews support for defining VSTS Build pipelines using YAML files checked into source repositories. This allows CI definitions to evolve alongside code, enabling source-centric workflows like pull requests and code reviews for CI. Users opt-in to the 'Build YAML definitions' preview feature and create a .vsts-ci.yml file in their Git repository root. Committing this file automatically configures a new build definition that runs on changes to the master branch. The preview currently supports CI, with plans to bring CD online later. It utilizes the existing VSTS automation system, supporting all inbox, custom, and marketplace tasks on both private and hosted agents.
  17. Managing Release NotificationsThis post announces the general availability of release notifications in Visual Studio Team Services (VSTS) and TFS 2018. It details default subscriptions for releases, which are pre-configured and opted-in for all users, and explains how account administrators can disable them. It also covers custom subscriptions, allowing users and teams to subscribe to additional notifications, and provides FAQs on configuring and managing these notifications.
  18. How do we use RM for our test runsThis post details the successful migration of internal VSTS organization testing systems from homegrown tools (RollingTest, tfsruns) to Azure Release Management (RM). It outlines the feature requirements that enabled this transition, including task group reusability, queuing policies, branch/tag filters, deployment status widgets, and task timeouts. The post describes the current usage of RM for setting up CI pipelines for microservices, analyzing failures, and checking release readiness, demonstrating a streamlined workflow for engineers and release owners. It also lists pending 'good to do' features like test deployments in PR workflows and commit-to-deployment status tracking.
  19. Personalize what notifications you receive for releasesThis post introduces a new feature for personalizing release notification settings within Azure DevOps. Previously, release definition authors controlled notification settings, leading to confusion. The new system provides out-of-the-box default notifications for all users, allowing individual users to opt-out or customize their subscriptions. This includes notifications for pending approvals, deployment completions, and other release events. The feature is available for Team Services and not for Team Foundation Server. It also details how to enable the preview feature and manage personal and team notification settings.
  20. New Release Definition Editor in Team ServicesThis post introduces a new release definition editor for Team Services, featuring a pipeline view that graphically represents deployment progression across environments. It highlights in-context configuration for artifacts, environments, approvals, and deployment settings. The editor also includes an improved task and phase editor with drag-and-drop functionality, centralized variable management for releases and environments, and the ability to apply deployment templates. The feature is currently in early adopter phase.
  21. Defining variables while creating a Release in RMThis post introduces the capability to define and modify variables during the creation of a Release in Azure Release Management (RM), similar to how it can be done when queuing a Build. It details a step-by-step process involving creating a Release in 'Draft' mode, editing the desired variables (e.g., changing 'a1' to 'foo2'), saving the draft, and then starting the release. This allows for on-the-fly customization of release variables before the release is initiated.
  22. Announcing General Availability of the New Build EditorThis post announces the general availability of a new build definition editor in Visual Studio Team Services and Team Foundation Server 2017 Update 2. Key improvements include a more intuitive getting started experience with templates, easier task searching and adding/reordering, the introduction of 'Process parameters' to bubble up important fields for quick configuration, and a cleaner UX for task input forms.
  23. How we use RM – Part 1This post details issues encountered and fixes rolled out for the internal use of Release Management (RM) for VSTS deployments. It addresses un-actionable error messages by changing PowerShell scripts to log inner exceptions, improves traceability by introducing 'Release-level-approvals' to avoid unnecessary ring traversals, and discusses the need for agent upgrades to resolve large log file upload issues. It also outlines plans for per-scale unit environments to improve log clarity and introduces the 'Resume task on timeout' feature for manual interventions to replace 'sleep' tasks.
  24. Configuring your release pipelines for safe deploymentsThis post details how to configure Azure DevOps release pipelines for safe, gradual deployments to multiple environments. It outlines strategies for phased rollouts across regions based on load, the use of feature flags for granular control, and the importance of a uniform deployment workflow using task groups and parameterized environment variables. It also emphasizes manual approvals, role segregation, health checks with manual intervention, branch filters for production deployments, and securing release pipelines through permissions.
  25. Managing Configuration and App Settings for Multiple Environments in Your CD PipelineThis post details how to manage configuration and app settings for multiple environments in a CD pipeline using Visual Studio Team Services. It explains two approaches: transforming web.config files before deployment using the 'Azure App Service Deploy' task with XML variable substitution, and applying settings directly to Azure websites using PowerShell cmdlets like 'Set-AzureRmWebApp' or a marketplace extension. It highlights the benefits of managing configuration through VSTS, including maintainability, reduced update locations, fewer mistakes, enhanced security, and increased reliability.
  26. Azure App Services Continuous DeliveryIntroduces a preview of the Continuous Delivery feature for Azure App Services directly within the Azure portal. This feature simplifies the setup of a CI/CD pipeline by guiding users through choosing a source repository (VSTS, GitHub) and application type (ASP.NET, ASP.NET Core). It automates the creation of build and release definitions in Team Services, sets up service endpoints, and can optionally configure load tests and staging environments. The process involves building, packaging, deploying to staging, and then promoting to production via a slot swap.
  27. Feature flags: How we control exposure in VS Team ServicesThis post details how Team Services uses feature flags to decouple deployment from exposure, allowing granular control over feature availability from global to individual user scope. It explains that feature flags are essentially inputs to if statements in code, enabling features to be enabled or disabled without redeploying services. An example is provided for controlling the visibility of a 'revert pull request' feature.
  28. Pricing for Release Management in TFS "15"This post details the finalized pricing model for Release Management in TFS "15". Key changes include making Release Management available to all Basic users (no additional per-user charge beyond TFS CAL), offering one free concurrent release pipeline per TFS server, and charging $15/month for each additional concurrent pipeline. It also clarifies that agents are free and that Visual Studio subscription contributions to concurrent pipelines are still being finalized. The post announces that these pricing changes are effective from TFS "15" RC2, with ala-carte extension purchases from the Marketplace expected by TFS "15" RTM.
  29. Continuous deployment/delivery with Jenkins and VS Team ServicesThis post details how to integrate Jenkins CI pipelines with Azure DevOps Release Management for continuous deployment. It outlines the steps to set up a Jenkins project to archive build artifacts, create a Jenkins service endpoint in Azure DevOps, link the Jenkins build project as an artifact source in a Release Definition, and configure deployment steps. Additionally, it explains how to use the 'VS Team Services Continuous Deployment' Jenkins plugin to automatically trigger Azure DevOps releases upon completion of Jenkins builds, leveraging REST APIs and Personal Access Tokens (PATs) for authentication.
  30. Release Management in TFS 2015 Update 2This post announces the integration of Release Management (RM) features directly into Team Foundation Server (TFS) 2015 Update 2, making them accessible via a new 'Release hub' in the TFS web interface. It highlights key RM capabilities such as deploying various apps to diverse targets, orchestrating deployments across environments, managing artifacts from Team Build or Jenkins, and tracking associated builds, commits, test results, and work items. The post also details the pricing model for these features, making them available to Basic access level users in trial mode, and outlines the planned licensing for full availability. It also announces the deprecation of the older server-client (WPF) version of Release Management and encourages migration to the new web-based version, providing guidance on manual migration and addressing potential feature gaps.
  31. Using parallel environments and release promotion in test automationThis post details the integration of parallel environments and release promotion into Azure Release Management Online (RMO) for test automation. It describes how to consolidate multiple release definitions into a single one with multiple environments, using deployment conditions to control the flow between them. A specific use case for testing an Application Tier (AT) vs. Data Tier (DT) mismatch scenario is presented, demonstrating how release promotion can be used to trigger specific test suites based on the success of prerequisite environments. The post also outlines the process of converting existing release definitions into environments within a new, consolidated definition, including manual variable migration.
  32. Impact of new Release Management orchestration featuresThis post introduces significant orchestration improvements to Release Management, allowing for more complex release definitions with parallel deployments to multiple environments, breaking the constraint of a linear pipeline. It also introduces manual promotion to specific environments. The post details how existing release definitions are migrated, including default deployment conditions, and addresses frequently asked questions regarding the new UI, selecting target environments, canceling in-progress releases, and controlling deployment permissions per environment.
  33. Using Release Management for Test AutomationThis post highlights the use of Release Management for test automation, referencing a companion article that details how the Release Management team dog-foods the service for deploying and testing applications daily or per check-in.
  34. Moving from the server-client versions of Release management to the web-based one in VS Team Services and TFSThis post provides guidance on migrating from older, client-based versions of Release Management (Server 2013/2015) to the newer web-based Release Management service in Visual Studio Team Services (VSTS) and Team Foundation Server (TFS). It outlines strategies for moving from vNext release templates and agent-based release templates, including leveraging PowerShell/DSC scripts and exploring marketplace extensions or migration tools. It also addresses client version compatibility errors when connecting to the VSTS RM service.
  35. Announcing the new Release Management service in Visual Studio Team ServicesThis post introduces the new Release Management service in Visual Studio Team Services (VSTS) for automating application deployment to multiple environments. It provides a step-by-step walkthrough for deploying a simple ASP.NET 4.5 website to Azure, covering code check-in, build definition creation (using MSBuild arguments for packaging), Azure service endpoint setup (using certificate authentication), and release definition creation with an Azure Website Deployment template. It also details linking build artifacts and setting up automatic release triggers upon build completion.
  36. Release Management vNext PlansThis post announces the upcoming vNext version of the Release Management Service in Visual Studio Team Services (VSTS), which will be publicly available later in the year. It highlights the limitations of the current WPF client-based service (no browser interface, Azure-only deployments) and details the improvements in the vNext service: a web-based interface, simplified concepts (Release Definitions, Environments), distributed task execution infrastructure shared with Build vNext, and integrated security permissions. It also covers deployment capabilities for Azure resources (websites, cloud services, resource groups), on-premises resources via agents, Linux deployments (Shell scripts, DSC, Chef), and integration with Jenkins and on-premises TFS builds. Traceability features for work items, commits, and test results are also mentioned, along with continuous deployment setup.
  37. Announcing Octopus Deploy integration for Visual Studio OnlineIntroduced integration with Octopus Deploy for Azure DevOps Build vNext. This integration allows for the creation of Octopus Deploy Releases as a separate step in build definitions. Two options are provided: a custom build step with a UI and release notes, and a PowerShell script. The OctoTFS repository on GitHub hosts these integration components.
  38. Release Management announcements at //Build 2015This post announces upcoming features for Release Management at //Build 2015, including a web interface, simpler release definition authoring, a summary of releases view, integration with Chef and Docker, and support for deploying to on-premise machines from VSO RM service. It clarifies timelines for VSO customers (Summer 2015) and on-premise customers (TFS 2015 Update 1), and discusses migration strategies from older versions. It also mentions incremental bug fixes in Release Management server, client, and agent for 2015 RC and RTM.
  39. Release Management Service FuturesThis post announces future enhancements to the Release Management Service in Visual Studio Online, including a web interface for authoring release definitions, initiating releases, managing approvals, and viewing summaries. It also details the upcoming ability to deploy to on-premise environments from VSO by setting up on-prem agents for builds and releases, and an expanded task catalog with more out-of-the-box deployment and testing tasks for Azure websites, PowerShell scripts, command-line tools, Chef cookbooks, and automated tests.
  40. What’s new in Release Management for VS 2013 Update 4?This post announces Release Management for Visual Studio 2013 Update 4, detailing 10 key features: 1. Integration with the Release Management Service in Visual Studio Online (VSO) for cloud-based release pipelines. 2. Ability to release to Azure directly from Visual Studio using the VSO service. 3. Support for server tags in Azure and on-premises environments to streamline deployments to multiple servers and control deployment order. 4. Access to system variables (e.g., build directory, build number, stage name) within deployment scripts. 5. Configuration variables for agentless deployments to manage reusable settings like credentials. 6. Manual intervention steps within release stages for manual validation or sign-off. 7. Support for deploying from build drops stored directly on TFS servers. 8. Deployment from build drops located on shared UNC paths. 9. Usability improvements including dropdowns for servers/components and friendly action names. 10. Ability to mix Azure and standard environments within a single release path. The update also includes performance optimizations and bug fixes.
  41. Trigger Release from build with Release Management for Visual Studio 2013 Update 3This post introduces new REST APIs (InitiateReleaseFromBuild and InitiateRelease) for triggering releases from TFS build agent machines without requiring the Release Management client installation. It provides sample PowerShell scripts and API endpoints for interacting with Release Management Update 3, enabling automated release initiation based on build completion. It also details how to use the releaseId to monitor release status and provides guidance on integrating these scripts into build definitions to control build success/failure based on release outcomes.
  42. How to setup Azure environments for Agent-less deployments in Release Management 2013 with Update 3 RTMThis post details the setup of Azure environments for agent-less deployments in Release Management 2013 with Update 3 RTM. It outlines the steps to create Azure VMs within cloud services, link Azure subscriptions and cloud services to Release Management environments, and then link Azure VMs as servers to these environments. Configuration variables for deployment actions can also be added at the server level. The post includes screenshots and links to related documentation for creating VMs, managing subscriptions, and deploying to Azure environments.
  43. How to deploy to Standard or Azure environments in Release Management 2013 with Update 3 RCThis post details the use of Release Management 2013 Update 3 RC for agent-less deployments to Standard (on-premises) and Azure environments using PowerShell and Desired State Configuration (DSC). It outlines the prerequisites for PowerShell and DSC, the steps for authoring deployments in both Standard and Azure environments, and the configuration parameters for server name, credentials, script paths, and secure connections (CredSSP, UseHTTPS, SkipCaCheck). It also highlights differences between the vNext release pipeline and agent-based pipelines, noting unsupported features like rollback controls within other flow controls and WinRM session timeouts requiring manual configuration.
  44. How to setup environments for Agent-less deployments in Release Management 2013 with Update 3 RCThis post details how to set up environments for agent-less deployments in Release Management 2013 Update 3 RC. It covers using Windows PowerShell or Windows PowerShell Desired State Configuration (DSC) for deployments to on-premise (Standard) and Azure environments without requiring the Microsoft Deployment Agent. Prerequisites include PowerShell version 4.0+ on target servers. For Azure environments, it outlines importing Azure subscription details (ID, Management Certificate Key, Storage Account Name) and notes that only IaaS VMs are supported. For on-premise environments, it requires PowerShell remoting and WinRM configured for HTTP/HTTPS communication.
  45. Release Management Update 3 CTP1 is now available with DSC Deployment Feature!Introduced Desired State Configuration (DSC) deployment as a feature in Visual Studio Release Management 2013 Update 3 CTP1. This allows for app deployments to on-premise and Azure environments without requiring a deployment agent on target servers, by leveraging PowerShell scripts executed via DSC.
  46. Release Management for Microsoft Visual Studio 2013 with Update 2 is live!This post announces the release of Release Management for Microsoft Visual Studio 2013 with Update 2. This update introduces the ability to easily execute components/actions on groups of servers and achieve continuous deployment from any CI system, including Visual Studio Online. It also provides links to download installers for the Release Management Server, Client, and Microsoft Deployment Agent, along with related KB articles and installation/user documentation.
  47. Release Management - Continuous Deployment with Visual Studio Online and any CI SystemsThis post introduces an updated Release Management command line tool (ReleaseManagementBuild.exe) that enables triggering releases from any CI server, including Visual Studio Online. It details how to modify build templates to include a call to this tool, specifying the release template name, package location, and target stage. The post also outlines requirements for the build agent and build definition when using this functionality for continuous deployment.
  48. Visual Studio Release Management 2013 Update 2 RC now availableThis post introduces the ability to tag servers in Release Management 2013 Update 2 RC, allowing for simplified deployment to groups of servers and parallel execution of deployment sequences. It also adds new options to the Release Management command-line tool (ReleaseManagementBuild.exe) for triggering releases from third-party CI systems, enabling continuous deployment.
  49. Did you uninstall Release Management Server and lose access to the Release Management client?This post addresses a specific client-server configuration issue that arises when the Release Management Server is uninstalled, leaving the Release Management client unable to connect. It introduces a command-line tool, `ReleaseManagementConsoleAdjustConfigFile.exe`, included with VS Update 2, to update the client's configuration file with a new server URL. Alternatively, uninstalling and reinstalling the client is presented as another solution.
  50. How to modify the UpgradeTemplate.xaml to enable releasing from a buildThis post details how to modify the `UpgradeTemplate.xaml` build process template to enable triggering releases from a build. It provides specific snippets and instructions for integrating release-specific customizations into existing custom `UpgradeTemplate.xaml` files, and outlines considerations for using the `ReleaseUpgradeTemplate.xaml` build process template, including installing the Release Management client and configuring build definition parameters like `Release Build` and `Release Target Stage`.
  51. How to configure Team Foundation Server with Release ManagementThis post details the necessary minimal permissions for a service account to communicate with TFS for Release Management, recommending an account in the 'Project Collection Service Accounts' group and outlining specific collection and team project level permissions. It also specifies supported TFS versions (2010, 2012, 2013) and notes that Visual Studio Online is not yet supported.
  52. Configuring Release Management to work across untrusted domainsThis post details the configuration steps for Release Management (RM) Server and Deployment Agent to work across untrusted domains. It outlines the creation of a local 'Shadow Account' on each machine, its addition to the Administrators group, and its configuration within Release Management with 'Service User' and 'Release Manager' permissions. For the Release Management Client, it describes configuring a Windows Credential in the Credential Manager on the client machine to enable authentication to the RM Server in a different domain.
  53. How to modify the TFS 2013 default build process template (GitTemplate.12.xaml & TfvcTemplate.12.xaml) to enable releasing from a buildThis post details how to modify the default TFS 2013 build process templates (GitTemplate.12.xaml & TfvcTemplate.12.xaml) to enable releasing from a build. It provides specific instructions for users with default templates (using ReleaseGitTemplate.12.xaml and ReleaseTfvcTemplate.12.xaml) and those with customized templates (using a provided snippets file). It also outlines considerations for using the Release Management build process template, including installing the client, setting 'Release Build' to TRUE, and specifying the 'Release Target Stage'.
  54. Release Management for Visual Studio 2013This post announces Release Management for Visual Studio 2013, a continuous delivery solution for .NET and Windows Server applications. It automates the release process through all environments from TFS to production, integrating with TFS. It allows configuration, approval, and deployment of applications to any environment with automated deployment orchestrations. It improves coordination between development, operations, and QA for repeatable, visible, and efficient release cycles.