ISSUE 086  ·  17 NOVEMBER 2026 ELEN RSS
CodeCity
AUTOMATION № 0056

Pulumi: you write the infrastructure, not click it together

Pulumi is a command-line tool that lets you describe and build cloud infrastructure with code instead of manual clicks. In our test, it could create projects, show changes before applying them, and keep stack and state history.

Pulumi: γράφεις την υποδομή, δεν τη στήνεις με κλικ

Two words first

If you are tired of opening five consoles and trying to remember which one got which network, Pulumi gives you a cleaner path. You write the infrastructure in files, and the tool reads them to create what is missing, change what broke, and clean up what you no longer need.

That is what infrastructure as code means. We are not talking about a simple script that runs once. We are talking about a description that becomes the source of truth. The same file says what should exist, what name it should have, which region it should live in, and how the pieces should connect. Pulumi takes that description and passes it to cloud providers, meaning the programs that know how to talk to each service and make the real API calls to it.

Think of it as a work plan that does not stay on paper. Instead of setting up a server, a database, and a network through separate steps in different places, you write the intention once. Then Pulumi can show what will change, apply it, and remove it when you are done. That is why teams that want repeatability use it, and so do people who got tired of trying to remember which button they clicked yesterday.

It also removes a lot of everyday friction. You do not have to remember who made the last click in a console, or rebuild the same thing from scratch in a second environment because the first one drifted. The description stays the same and works as the shared point of reference. If something changed yesterday, you see it in the plan, not only in someone’s memory of “the one who set it up.” That helps when a team grows, but also when you work alone and come back to a project after days away.

What it does

Pulumi organizes infrastructure into stacks, meaning separate versions of the same project for different purposes or environments. One stack can be for testing, another for production. That keeps temporary things away from live ones. Each stack keeps its own state, meaning the file that remembers what already exists and how it is connected.

State is the project’s memory. Without it, the tool would see an empty world every time and try to rebuild everything from scratch. With it, it knows what already exists, what has been renamed, what should stay, and what should go away. That is the key. You do not just write “create a server.” You write the desired end state and let the tool compare what exists with what you want to exist. That is where control comes from, because the gap between the current picture and the desired picture becomes the map of change.

The useful part is that Pulumi does not force you to learn a fake vocabulary just because you are talking about infrastructure. You can write in TypeScript, JavaScript, Python, Go, C#/.NET, Java, or YAML. In our test, the subcommand list showed that the tool works like a normal CLI and not like a closed environment. That helps when you want a workflow that fits into an editor, continuous integration, and a terminal without changing habits.

A simple flow shows it clearly. You write the project, look at the preview, apply the change, and then clean up what you created when you are done. In practice that means you describe the goal first, then see whether the goal matches reality, then give the okay for the change, and finally clean up. This is not only about convenience. It is a way to avoid surprises that cost time and cause mistakes.

A second thing it does well is checking before changing anything. The preview command reads the current state and the plan you wrote and shows what will happen if you continue. That is the point that saves time and damage. If the plan is wrong, you see it before opening accounts in services you would later have to clean up by hand.

The third is the connection to many providers. A provider is the package that knows how to speak to a specific service, such as AWS, Azure, GCP, or Kubernetes. Pulumi has hundreds of them, so it does not stay tied to one world. That matters because real infrastructure rarely lives in one cloud or in only one class of service.

The fourth is that it keeps a change history. It does not look only at the final result. It remembers what was updated, when, and by whom. For teams, that means fewer guesses when something changes suddenly and the blame hunt starts.

What it does not do

Pulumi is not a magic button that creates a good architecture on its own. If you write a bad description, you will get bad infrastructure in a more polished way. The tool enforces a flow, not judgment. That matters, because otherwise the promise of automation becomes an excuse to build the wrong things faster.

It is not just a shell script you run and forget about tomorrow either. It needs a backend to store state. That backend can be your Pulumi Cloud account or a local file. With a local backend, it wants a passphrase to protect the secrets in state. In our test, pulumi new stopped there when PULUMI_CONFIG_PASSPHRASE had not been set. With the variable defined, pulumi stack init dev continued.

It also does not hide your secrets by itself. Secrets live inside the state flow and need care in how you store them and who reads them. If the network, backend, or permissions are sloppy, Pulumi will not save you from that.

Finally, it is not a product that replaces cloud knowledge. If you do not know what subnet, policy, role, or region means, Pulumi will help you write them, but not understand them from zero. It is a tool there, not a teacher.

How to use it

Installation is simple from the user side and heavy only in the download. The official Windows file we tested unpacks into a large folder because it also carries the language helpers. That is not a problem in use. It is a reminder that one tool supports many languages and has to bring everything it needs to work locally.

Download Pulumi from the installation page and check that the binary runs.

pulumi version

Then connect the CLI to a backend. If you do not want a cloud account, go local.

pulumi login --local

For a new project, choose a template. YAML is good when you want to see the logic clearly.

pulumi new yaml --name trap-proj -y

If you are working with a local backend, set a passphrase so the state file does not stop at secrets.

set PULUMI_CONFIG_PASSPHRASE=your-passphrase

Then initialize a stack.

pulumi stack init dev

And before going further, see what will change.

pulumi preview

That is enough to get started. After that, you put code in the project file, define config, and when you are ready you run apply. The logic is always the same: write, check, apply, clean up.

Each command has its own job. Version tells you which binary you are looking at and whether you are talking to the right tool. login –local ties the CLI to a local backend and keeps state on disk, without going through a cloud account. new creates the outline of the project and the first files. passphrase protects the local state, so anything considered secret does not sit exposed. stack init sets up a new stack for the environment you chose. preview shows you the difference before any change happens. If you know those six moves, you already know the basic route through Pulumi.

How to drive it from the shell

This is not an MCP server. It is a command-line tool with subcommands. That means you use it like any other CLI: open a terminal, go into the project folder, and call the command you want. You do not need to declare it as a service anywhere, and you do not need a separate middle layer.

The basic use looks like this.

pulumi up

If you want to remove what you created, it is just as simple.

pulumi destroy

The important thing is to remember that Pulumi expects a project with a config file and a stack. It is not a command you run in the air. It wants a folder, files, and state. That makes it useful in real work, but not a standalone toy.

Our hands-on test

In our test, the first thing that showed up was that the version matched what the sources said immediately. pulumi version answered right away with v3.274.1. That is not impressive only as a number. It matters because it means the tool opens quickly and does not ask for strange preparation before you start working.

Then we looked at local access without a cloud account. pulumi login --local worked and put the state in a local file. That is practical for tests and small projects. It lets you experiment without opening accounts and without being forced into a platform’s policy right away.

The point where it showed its real limit was pulumi new yaml --name trap-proj -y. The project was created, but the flow stopped with a message saying it needed a passphrase in the PULUMI_CONFIG_PASSPHRASE variable. That is not a one-off bug. It is the behavior you expect when you keep secrets locally. With the variable set, pulumi stack init dev passed and the stack was created.

Then came the preview. That is where the tool’s usefulness showed up without making any real change. pulumi preview finished in 0.95 seconds and showed one item to create, meaning the stack resource itself. That is the kind of answer you want before giving the green light. You see what will exist before it actually exists.

It is also important what we did not need. We did not enter cloud credentials, we did not create a real resource, and nothing was billed. The test stayed in local state and preview. If you wanted a real deploy, you would need an account with the provider you choose, the right permissions, and a more careful check of the resources you would touch. That changes the risk too. You move from “what will be created” to “what will be billed, what will stay alive, and who will manage it later.”

One more useful point was the subcommand list. The tool does not box you into one or two actions. It offers new, config, stack, console, import, refresh, state, install, up, destroy, preview, cancel, env, and Pulumi Cloud commands. That says a lot about its philosophy. It is not only for creating things. It is also for managing, rechecking, cleaning up, and keeping things in shape day to day.

Our test also showed something else: Pulumi is fast when you put it on a clean path, but it does not let you skip the basics. It wants a backend. It wants a stack. It wants clear configuration. That can feel strict the first time, but in a real project it is exactly the kind of strictness you want.

What it costs

Here we measure what someone pays in tokens, space, and money to use Pulumi.

Tokens: zero. Pulumi is not a server you declare in a model — it does not load any tool schema into any model’s context. You call it from the shell, the result stays in your terminal or project files, and the model sees none of it unless you give it that yourself. This is not a guess: it follows from the flow, because there is no server to declare anywhere.

Space: the heaviest part. The official Windows file is 103,639,556 bytes (about 98.8 MB) and unpacks into a 288 MB folder, because it carries helpers for bun, .NET, Go, Node.js, Python, and YAML. If you work in only one language, most of that space sits unused on disk — that is the real price of “one command, all languages.”

Money: the tool is free, the account is not always. The code is open under Apache-2.0: no key, no subscription, no account if you stay on a local backend. Pulumi Cloud and collaboration tools have commercial tiers — that is stated by the maker, not priced by us. And the real cost is not the software: it is the infrastructure you build with it, which is billed by the cloud provider, not by Pulumi.

And the time: in our test, preview returned in 0.95 seconds with no cloud credentials — meaning you see what is about to happen before you commit anything.

When it is worth it

This is not a prototype. On GitHub, the pulumi/pulumi repository has 25,899 stars and 1,514 forks, with 2,493 open issues and a last push on 11/11/2026; the license is Apache-2.0 and the latest release is v3.274.1, published on 5/11/2026. On npm, the @pulumi/pulumi package records 5,094,472 weekly downloads, and on PyPI the version is 3.274.1 with Requires-Python 3.10 and above. This is not a toy one person only tried in isolation.

It is worth it when you have infrastructure that changes often and you do not want every change to feel like a small improvised project. It is worth it when your team already writes code in one of the supported languages and you want the same mind to build both the app and the infrastructure. It is also worth it when you want control before deploy and a clean teardown afterward.

It is not worth it when you have a small static site that does not change. There Pulumi is more discipline than you need, because you do not have ongoing change to manage. It is not worth it either when you are talking about a single server that was set up once and stays the same for a long time. Then state, stacks, and extra structure add weight without giving enough back.

For teams that do serious infrastructure, though, Pulumi makes sense. It lets you write fewer buttons and more intent. And when you do that well, it saves mistakes that later cost more than the time it took to set things up properly from the start.

End

Pulumi is one of those tools that works well when you use it with a clear plan. It does not hide the complexity of infrastructure. It makes it written, and therefore controllable. That is the gain. If you want fewer clicks and more decisions to remember, this is the right place.

Sources:

https://github.com/pulumi/pulumi

https://www.pulumi.com/docs/iac/

https://www.pulumi.com/docs/iac/get-started/

https://www.npmjs.com/package/@pulumi/pulumi

https://pypi.org/project/pulumi/

Εγκατάσταση

5 ΒΗΜΑΤΑ
  1. pulumi version
  2. pulumi login --local
  3. pulumi new yaml --name trap-proj -y
  4. pulumi stack init dev
  5. pulumi preview
Pulumi: you write the infrastructure, not click it together · ΑΠΟΤΕΛΕΣΜΑ
ΠΗΓΗ
github.com/pulumi/pulumi