cloudparts

Pulumi

Infrastructure as code in TypeScript, Python, Go, C#, Java, YAML or HCL: a program declares resources, and Pulumi’s engine diffs them against saved state and calls the cloud APIs through providers.

What it is
Infrastructure as code
Type
Open source
Made by
Pulumi Corporation
License
Apache 2.0 (the CLI, engine and SDKs); Pulumi Cloud is a commercial service
Facts checked
23 October 2026
Website Source code

What it is

A Pulumi program is ordinary code that creates resource objects, such as new aws.s3.Bucket("uploads"). When you run pulumi preview or pulumi up, a language host runs the program and reports each resource to the deployment engine. The engine compares that desired state with the state saved from the last run and decides, per resource, whether to create, update in place, replace or delete it; resource plugins called providers then make the API calls. Values that only exist after creation, such as an ID or a DNS name, are Output objects, which work like promises: you transform them with apply or pulumi.interpolate rather than reading them directly.

Each program can be deployed as several stacks, isolated instances such as dev and prod, with per-stack settings in Pulumi.<stack>.yaml; one stack can read another’s outputs through a stack reference. State goes to Pulumi Cloud by default, or to a backend you run: S3, Azure Blob Storage, Google Cloud Storage, an S3-compatible server, PostgreSQL or a local directory. Secret values are encrypted inside the state whichever backend you choose. Providers are either native, generated from a cloud’s own API specification (Azure Native, Kubernetes), or bridged from Terraform and OpenTofu providers (AWS and Google Cloud among them); pulumi package add terraform-provider wraps any other Terraform provider with a generated SDK.

The CLI, engine and SDKs are open source under Apache 2.0 and can run entirely with your own backend. Pulumi Corporation sells Pulumi Cloud: free for one user, with paid editions billed per managed resource. In August 2026 HCL became a fully supported Pulumi language, along with native Terraform modules and Pulumi Cloud as a Terraform state backend, aimed at teams moving from Terraform. Releases come several times a week; v3.272.0 shipped on October 22, 2026.

Why teams pick it

  • Real languages with their package managers, IDEs and test frameworks, and components that can be shared across languages
  • Covers many clouds and SaaS APIs, because nearly any Terraform provider can be used alongside Pulumi’s native ones
  • The Automation API embeds the engine in your own software, for internal platforms, custom CLIs or tests
  • Secrets are encrypted in state by default, and state can live in Pulumi Cloud or in your own bucket or database

Watch out for

  • Like Terraform it keeps a state file that has to be stored, shared and protected; the default backend means an account with Pulumi Cloud
  • Many major providers, including AWS and Google Cloud, are bridged from Terraform providers, so their resources follow the Terraform versions
  • Outputs are asynchronous values, which surprises newcomers who try to print an ID or use it in an if
  • Arbitrary code makes programs harder to review than declarative files: the pulumi preview output, not the diff, shows what will change

Alternatives

What all infrastructure as code have in common →Compare side by side →
AWS Cloud Development Kit (CDK)AWSDefine AWS infrastructure in TypeScript, Python, Java, C# or Go; the CDK turns it into CloudFormation templates and CloudFormation deploys them.

How it fits with other technologies

index.ts: a bucket that differs per stack, and an exported output · ts

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const stack = pulumi.getStack();         // "dev", "prod", ...
const config = new pulumi.Config();
const team = config.require("team");   // from Pulumi.<stack>.yaml

const uploads = new aws.s3.Bucket("uploads", {
  forceDestroy: stack !== "prod",        // keep prod data on delete
  tags: { team, stack },
});

// uploads.bucket is an Output: known only after the bucket exists
export const url = pulumi.interpolate`s3://${uploads.bucket}`;

// $ pulumi stack init dev
// $ pulumi config set team payments
// $ pulumi preview   -> what would change
// $ pulumi up        -> apply it

See it in a real stack

No architecture uses Pulumi yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2017–2026

Joe Duffy and Eric Rudder began exploring the idea in late 2016 and founded Pulumi in 2017. Duffy’s frustration was configuration: for every serverless function he wrote dozens of lines of JSON or YAML, and he argued that cloud architecture should be written in the general-purpose languages developers already use, not in YAML or a domain-specific language. Pulumi launched as open source on June 18, 2018, with JavaScript, TypeScript, Python and Go, for AWS, Azure, Google Cloud and Kubernetes.

Pulumi 1.0 followed on September 5, 2019, with state management across environments, built-in secrets encryption and a free community edition beside paid team plans. Version 3.0, on April 20, 2021, made the Automation API generally available, added native providers generated from cloud API specifications, starting with Azure, and let components written in one language be used from all of them.

Rather than write every provider from scratch, Pulumi reuses many of Terraform’s through a bridge, and in 2026 it went further toward Terraform users: HCL programs, Terraform modules and Pulumi Cloud as a Terraform state backend became generally available in August 2026. Pulumi’s engine also became the base of other tools, notably SST, which moved onto it from the AWS CDK in 2024.

Why it’s built this way

General-purpose languages instead of a DSL
Loops, functions, classes, packages and IDE support come with the language, so infrastructure can be abstracted and reused like any other code.
A language host separate from the deployment engine
The program only describes resources; one engine computes the diff and applies it. That keeps behaviour the same across languages and makes adding a language a matter of a new host and SDK.
Bridge Terraform providers rather than rebuild them
Hundreds of providers already existed for Terraform. Wrapping them gave Pulumi broad coverage early, while native providers generated from API specs fill in where coverage matters most.
A hosted backend by default, with a do-it-yourself option
Pulumi Cloud handles state, history and secrets out of the box, and teams that can’t use a SaaS can still point the open-source CLI at their own storage.

Timeline

  1. 2017

    Pulumi founded by Joe Duffy and Eric Rudder

  2. 2018

    Open-source launch on June 18

  3. 2019

    Pulumi 1.0 generally available on September 5

  4. 2021

    Pulumi 3.0 with the Automation API and native providers

  5. 2024

    SST v3 moves onto Pulumi’s engine

  6. 2026

    HCL, Terraform modules and Terraform state backend GA in August

Sources11 · facts checked 23 October 2026

Improve this page on GitHub