---
title: "Release pipelines as code – Pulumi Delivery"
description: "Write your release pipeline as a Pulumi program, and Pulumi Delivery runs each release through your stages and approval gates."
url: "https://www.pulumi.com/product/delivery/"
image: "https://www.pulumi.com/assets/og/product/delivery.png"
---

# Release pipelines as code – Pulumi Delivery

Write your release pipeline as a Pulumi program, and Pulumi Delivery runs each release through your stages and approval gates.

Your release process, **in code**

Replace the release glue in your CI jobs with one Pulumi program — Delivery moves each release through your stages and approvals.

- [Get started](https://www.pulumi.com/docs/delivery/get-started/)
- [Contact us](https://www.pulumi.com/contact/?form=sales)

## Replace release glue **with one program**

Teams with more than a few stacks end up writing release glue. A CI job updates the network stack, waits, updates the app stacks, then pauses for someone to check staging. Delivery replaces that glue with a Pulumi program you version and review like the rest of your code, and your CI goes back to building and testing.

- **Review release changes in pull requests:** Adding a staging environment or a new region is now a pull request your team reviews and merges.
- **Define deploy order in code:** Delivery reads the stack references in your programs and updates dependencies first.
- **Require approval before production:** A release waits at the production stage until your approvers sign off in Pulumi Cloud.

> At Andesite, we've been shipping every release out to ten separate customer environments by hand. It's a process that's struggling to scale. Delivery as code is the approach we've been looking for. Defining how a release gets to our customers in code means we can add customers without adding manual work.
>
> — Ben Miletic, Staff Software Engineer, Andesite

## A release pipeline is a **Pulumi program**

Point the pipeline at a repository on GitHub, GitLab, Bitbucket, or Azure DevOps and define its stages. Run `pulumi up` to create it, then push to your branch to start a release.

```typescript
import * as delivery from "@pulumi/delivery";

const app = new delivery.GitHubSource("app", {
    repository: "acme/shop",
    branch: "main",
    trigger: true,
});

const pipeline = new delivery.Pipeline("shop", {
    program: { source: app, directory: "delivery" },
});

const dev = new delivery.Stage("dev", { pipeline });
const prod = new delivery.Stage("prod", {
    pipeline,
    from: [dev],
    when: delivery.approval({ approvers: ["platform-leads"] }),
});

const devStacks = new delivery.Stacks("dev", {
    stage: dev,
    stacks: {
        app: { stack: "shop-infra/dev", source: app, directory: "infra" },
    },
});

new delivery.Job("smoke", {
    stage: dev,
    source: app,
    directory: "delivery",
    command: "sh smoke.sh",
    environment: {
        ENDPOINT: devStacks.outputs.apply(o => String(o["app"]["endpoint"])),
    },
});

new delivery.Stacks("prod", {
    stage: prod,
    stacks: {
        app: { stack: "shop-infra/prod", source: app, directory: "infra" },
    },
});
```

- **Deploy every region with a loop:** Write a function that deploys one region and loop over your list of regions — adding a region is a one-line change.
- **Group dependent stacks:** Delivery updates the stacks in a group in order, and each stack gets fresh outputs from its dependencies.
- **Run releases on Pulumi Cloud:** Stack updates and jobs run on Pulumi-managed runners, and you can pin a container image to control CLI and language versions.

## Promote each release **stage by stage**

Every release has to pass staging, your smoke tests, and its approvals before it touches production. If anything fails, the release stops.

- **What you tested is what ships:** Each release locks its commit when it starts — production gets exactly the code that passed staging.
- **The right people sign off:** Choose who approves each stage, and they see a preview of every stack update before anything changes.
- **Catch problems before production:** Smoke tests after each stage stop a bad release early, and a manual gate holds it for a hands-on check.
- **Separate credentials for every stage:** Each stage gets its own [Pulumi ESC](https://www.pulumi.com/product/secrets-management/) environment with short-lived credentials, and staging never holds production keys.

## Hand values **from one pipeline to the next**

When the platform team ships a new cluster endpoint to production, every app team's pipeline picks it up and redeploys on its own — no tickets or Slack pings between teams.

- **Only production-ready values:** Publish endpoints and image tags from a release, and other pipelines pick them up only after it reaches production.
- **Built for monorepos:** Each pipeline starts only when its own paths change, and one team's commit never redeploys another team's stacks.
- **Least privilege for every pipeline:** Each pipeline runs as its own service principal with access to just the stacks it deploys.

## When a release fails, **retry, roll back, or pause**

A failed release waits for you — Delivery never retries on its own, and you choose the fix from the Pulumi Cloud console or the REST API.

- **Retry what failed:** Rerun just the updates and jobs that failed, on the same commit, instead of restarting the whole release.
- **Roll back a stage:** Put a stage back on any earlier release, and hold new runs until you're ready.
- **Pause and force-promote:** Pause a stage while you investigate, or force-promote an urgent fix past its gate.
- **Control who can ship:** Let someone edit a pipeline without letting them approve or force-promote, and see every approval and stage change in the audit log.

## Build your first pipeline

Pulumi Delivery is in public preview. Set up a pipeline with a dev stage, a smoke test, and a prod stage behind an approval gate.

- [Get started](https://www.pulumi.com/docs/delivery/get-started/)
- [Book a demo](https://www.pulumi.com/request-a-demo/)

## How Delivery works

Follow a release through every stage, from commit to production.

- [Read the concepts](https://www.pulumi.com/docs/delivery/concepts/)
- [Connect pipelines](https://www.pulumi.com/docs/delivery/guides/multiple-pipelines/)

## Explore Pulumi

- [Product overview](https://www.pulumi.com/product/): The unified platform for infrastructure teams.
- [Pulumi IaC](https://www.pulumi.com/product/infrastructure-as-code/): Infrastructure as code in any language.
- [Pulumi Agents](https://www.pulumi.com/product/agents/): Put agents to work on your infrastructure.
- [Pulumi ESC](https://www.pulumi.com/product/secrets-management/): Centralized configuration, zero sprawl.
- [Discovery & governance](https://www.pulumi.com/product/discovery-governance/): Continuous compliance, by construction.
- [Pulumi IDP](https://www.pulumi.com/product/internal-developer-platforms/): Self-service infrastructure at any scale.
