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.
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.”
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.
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 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.
How Delivery works
Follow a release through every stage, from commit to production.
