Why can't my stage name have dashes in it?

Azure Pipelines stage identifiers (the value after `stage:`) must be alphanumeric plus underscores, unlike job names in most other CI systems. This tool validates that up front so you don't discover the restriction only after a failed pipeline run.

What does the pool vmImage field control?

It selects which Microsoft-hosted agent image runs your pipeline, for example `ubuntu-latest`, `windows-latest`, or `macos-latest`. Each hosted image comes with a different set of pre-installed tools and operating system.

How does the publish-artifacts option work?

When enabled on a stage, it adds a `- publish:` step pointing at the path you specify (defaulting to `$(Build.ArtifactStagingDirectory)`) with the artifact name you choose (defaulting to `drop`), which uploads that path so later stages or a human reviewer can download it from the pipeline run.

Can I add multiple jobs per stage?

This generator creates one job per stage to keep the form simple; if you need multiple parallel jobs within a single stage, generate the YAML here and then duplicate the `jobs:` entry by hand underneath the stage.

Azure DevOps Pipeline Generator - Build azure-pipelines.yml

Overview

Introduction

Azure Pipelines YAML nests trigger, pool, variables, and a stages → jobs → steps hierarchy, and it's easy to get the stage/job nesting level wrong or forget that stage identifiers can't contain dashes.

This tool generates a complete, valid azure-pipelines.yml from a form, with the trigger, pool, variables, and each stage's script and publish steps correctly nested.

What Is Azure DevOps Pipeline Generator?

A form-driven generator for Azure DevOps Pipelines YAML. You set the branches that trigger the pipeline, the pool's VM image, optional pipeline-level variables, and one or more stages, each containing script steps and an optional artifact publish step.

The output follows Azure Pipelines' `trigger → pool → variables → stages → jobs → steps` structure exactly as Azure DevOps expects it.

How Azure DevOps Pipeline Generator Works

Each trigger branch becomes an entry under `trigger.branches.include`, and each stage becomes its own `stage:`/`job:` pair (one job per stage) with a `steps:` list built from your script lines, each rendered as a `script:` step with a matching `displayName`.

Enabling publish-artifacts on a stage appends a `- publish:` step with the artifact path and name you provided, using Azure's default staging directory variable when no path is given.

When To Use Azure DevOps Pipeline Generator

Use it when setting up a new Azure DevOps project's pipeline and you want a working YAML file to commit and iterate on, rather than starting from the Azure DevOps UI's classic editor.

It's also useful for quickly sketching a multi-stage build/publish pipeline before filling in the real scripts and artifact names.

Often used alongside GitLab CI Generator, GitHub Actions Workflow Generator and Bitbucket Pipelines Generator.

Features

Advantages

Enforces Azure's stricter stage-name character rules up front, catching a common source of pipeline validation failures before you even save the file.
Automatically nests stages, jobs, and steps at the correct YAML indentation levels Azure Pipelines requires.
Generates a correctly formed artifact publish step without needing to remember Azure's staging-directory variable syntax.

Limitations

Only one job is generated per stage; pipelines needing multiple parallel jobs within a stage need manual editing afterward.
Doesn't cover pipeline templates, deployment jobs with environments/approvals, or matrix strategies.

Examples

A build stage with a script step and artifact publish

Input

trigger: main; pool: ubuntu-latest; stage 'Build' → script: npm install / npm run build; publish artifacts: dist, name: drop

Output

trigger:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

stages:
  - stage: Build
    jobs:
      - job: Build
        steps:
          - script: npm install
            displayName: 'npm install'
          - script: npm run build
            displayName: 'npm run build'
          - publish: dist
            artifact: drop

Each script line becomes its own step with a matching display name, and the publish toggle appends the artifact upload step.

Best Practices & Notes

Best Practices

Use descriptive stage names (Build, Test, Deploy) since Azure DevOps' pipeline visualization displays them prominently in the run summary.
Set pipeline-level variables for values reused across stages (like a build configuration) rather than repeating literals in every script step.
Publish build output as an artifact from the build stage rather than trying to pass files between stages another way, Azure Pipelines' stages run on potentially different agents with no shared filesystem.

Developer Notes

Azure Pipelines requires stage identifiers to match `[a-zA-Z0-9_]+`, unlike job/step names elsewhere which are more permissive, so this generator validates stage names against that exact character set before emitting YAML. The artifact publish step defaults to `$(Build.ArtifactStagingDirectory)` and artifact name `drop` when left blank, matching Azure's own pipeline templates and quickstart examples.

Azure DevOps Pipeline Generator Use Cases

Scaffolding a new Azure DevOps project's first azure-pipelines.yml
Migrating a classic (UI-defined) Azure DevOps pipeline to YAML-as-code
Producing a working build-and-publish pipeline to demonstrate a project's CI setup

Common Mistakes

Using a dash in a stage name (e.g. `build-stage`), which Azure DevOps rejects since stage identifiers only allow letters, numbers and underscores.
Assuming files persist between stages automatically, without publishing/downloading artifacts, each stage's job may run on a completely separate, clean agent.

Tips

If you need approvals before a deploy stage runs, add an `environment:` with checks in the Azure DevOps UI after generating this base pipeline, environments and approvals aren't expressible purely in this generator's form.

Azure DevOps Pipeline Generator