Cloud infrastructure has quietly become one of the most operationally demanding disciplines in modern engineering, and one of its most stubborn pain points has never been provisioning resources themselves but understanding what is actually happening while large deployments unfold. AWS recently shipped a meaningful upgrade to CloudFormation StackSets that finally addresses this visibility gap, introducing a stage-by-stage progress view for every operation that begins after the feature’s launch. For anyone who has stared at a single ambiguous “RUNNING” status while a rollout touched hundreds of accounts, this is the kind of unglamorous but genuinely transformative improvement that reshapes day-to-day work. The headline is simple: you can now see how much of a deployment is complete, precisely which accounts and stack instances are lagging or failing, and how each geographic Region is faring, all without waiting for the entire operation to grind to a halt. What makes this newsworthy is not novelty for its own sake but timing. As organizations increasingly operate hundreds or thousands of AWS accounts under frameworks like AWS Organizations and Control Tower, the ability to observe distributed changes in flight has shifted from a nice-to-have convenience into a core requirement for safe, auditable, and confidently managed cloud operations.

To appreciate why this matters, it helps to step back and consider how far infrastructure as code has traveled and where it still frustrates practitioners. Tools that let teams describe cloud environments in declarative files, whether hand-written YAML and JSON, generated through the AWS Cloud Development Kit, or expressed in third-party frameworks, have given us reproducibility, peer review, and version control for something that used to be clicked together by hand in a console. But most organizations did not stop at a single account. Security best practice, compliance requirements, and the sheer logistics of separating workloads have pushed enterprises toward multi-account architectures where a networking baseline, a logging pipeline, or a set of guardrail policies must be replicated identically across an entire estate. This is where things get hard. Applying one template to one account is trivial, but applying it consistently across dozens of Regions and hundreds of accounts, then tracking whether every single instance succeeded, is a fundamentally different problem. For years, teams coped with this by wrapping custom scripts around deployment calls, polling for status, and building homegrown dashboards, essentially reinventing observability tooling because the native platform gave them only a binary outcome.

CloudFormation StackSets exist precisely to solve the propagation problem. The concept is elegant: you define a template once, and a stack set becomes the mechanism that deploys that same template everywhere you target, with each individual deployment to a specific account and Region represented as a stack instance. When you choose service-managed stack sets, the platform leans on AWS Organizations to automatically create the cross-account roles it needs in every target account, sparing administrators from manually configuring trust relationships across an ever-shifting membership roster. This automation is enormously powerful, but power at scale magnifies the cost of opacity. If a single create operation fans out to two hundred and forty accounts across three Regions, that is seven hundred and twenty discrete stack instances, each of which could succeed, fail, be skipped, or be cancelled for its own reasons. Before this release, watching such an operation was like watching a freight train disappear into fog: you knew it had left the station and you knew its eventual destination status, but you had no window into the journey. The new progress reporting essentially installs a live telemetry feed into that black box.

The mechanics of the update are worth understanding because they reveal a thoughtfully designed feature rather than a cosmetic one. When you launch a stack set operation, its top-level status behaves exactly as it always has, so nothing in your existing mental model breaks. What is new is a richer layer of detail exposed through StatusDetails, surfaced in the DescribeStackSetOperation and ListStackSetOperations API responses and mirrored in a dedicated Progress tab on the CloudFormation console. Crucially, these stage-level statuses are deliberately kept separate from the overall operation status, which means a rollout can still read as RUNNING at the top while its constituent stages each report their own nuanced state underneath. In the console, you reach this view either by selecting the progress report link on a stack set’s Operations tab or by opening an operation’s details page and clicking the Progress tab. The tab is organized into up to three logical sections, adapting intelligently to context: self-managed stack sets omit the role provisioning panel entirely, and operations that do not provision roles, such as updates, mark that section as not applicable rather than showing misleading zeros. This contextual awareness signals that AWS designed the experience around real operational scenarios.

Diving into the console view, the progress report decomposes a deployment into readable, actionable components. The Role provisioning section, when present, reports the status alongside counts of accounts that succeeded, failed, are still pending, and the total in scope. The Deployment section carries the heart of the story, tracking stack instances across succeeded, failed, pending, cancelled, and skipped categories together with the overall total. Beneath that, a Deployment by Region breakdown repeats those same stack instance counts for each individual Region and even notes whether the platform is processing Regions sequentially or in parallel, which is a subtle but valuable operational hint for understanding throughput and timing. While an operation is actively running, a progress bar visualizes the deployment percentage complete, and once the operation concludes, that bar is replaced by the final stage status, giving you a clean end state without ambiguity. One detail that rewards close reading is that the completed count, defined as the sum of succeeded, failed, skipped, and cancelled, appears only in the API rather than the console, a reminder that the interface is tuned for quick human interpretation while the API serves programmatic and audit needs.

Understanding the two core stages individually transforms how you read these reports and, more importantly, how you diagnose problems. Role provisioning is the preliminary phase specific to service-managed stack sets, responsible for preparing the necessary access in each target account before any actual resources are touched. Once StackSets has resolved which accounts are in scope, this stage reports account-level counts and a percentage complete, and for any operation that does not provision roles, including everything on self-managed stack sets, it correctly reports as not applicable. The stack deployment stage then follows, only beginning after role provisioning concludes, and it is here that your template is actually instantiated as stack instances across accounts and Regions. A particularly smart design choice is how the platform communicates why a stack instance was not deployed: rather than a single opaque failure, it distinguishes between instances that were skipped and those that were cancelled, giving you diagnostic signal that was previously invisible. Each stage resolves to one of a defined set of statuses, and critically, the two stages can conclude differently, for instance role provisioning ending in partial success while deployment reports full success because every non-skipped instance went through cleanly.

A concrete scenario makes the value tangible. Imagine you are a platform engineer pushing an organization-wide baseline to two hundred and forty accounts across three Regions, seven hundred and twenty stack instances in total, and the operation has been running for roughly twenty minutes. Under the old paradigm, you would have nothing to report to stakeholders except that it was still churning. Now you open the Progress tab and see that role provisioning has already succeeded for all two hundred and forty accounts, that the deployment bar sits at ninety percent with six hundred and fifty-one instances succeeded, zero failed, and sixty-nine still pending, and that the regional breakdown tells an even more precise story: the US East Region is fully complete, Europe has just five instances remaining, and US West still has sixty-four to go. The API mirrors this with a percentage rounded down to the nearest tenth, so six hundred and fifty-one of seven hundred and twenty reads as ninety-point-four percent while the console simply shows ninety. That granularity lets you make real decisions in the moment, perhaps reassuring an anxious product team that the last Region is simply larger, or deciding whether to prepare a communication before the final instances land.

The second scenario is even more instructive because it demonstrates how the feature shines precisely when something has gone wrong. Picture a create operation targeting four accounts across three Regions, twelve stack instances in total, that finishes in seconds with an overall status of success, yet no stacks materialize anywhere. Historically this would have been a maddening mystery, a green checkmark attached to an empty result. The progress report explains it instantly: role provisioning failed for all four accounts, and deployment, technically succeeding because no instance actually failed, shows all twelve instances as skipped, with four skips in each Region. The root cause, in this case that all four target accounts were suspended within the organization, becomes obvious rather than something you spend an afternoon investigating. To drill into the reason for each account, you list the operation’s results and review the status reason, then confirm whether the accounts are active in AWS Organizations and re-run the operation for the recovered ones. This is the real payoff of stage-level visibility: it converts a silent, confusing no-op into an immediately diagnosable event, saving engineers from the especially draining experience of trusting a success signal that produced nothing.

For teams that live in pipelines rather than consoles, the API surface is where this feature earns its long-term keep. ListStackSetOperations returns the same stage details for recent operations without the regional breakdown, which is ideal for emitting a compact progress line into build logs so that a continuous integration run can surface deployment health at a glance. For a single operation, you can extract the stack deployment percentage directly and act on it, gating a pipeline stage or triggering a notification when progress stalls. A thoughtful forward-compatibility decision is that every stage is always present in the response for post-launch operations, populated with not-applicable or not-started values when inactive, so your automation reads an identical structure regardless of operation type rather than branching on whether you are creating, updating, or deleting. This uniformity is a gift to anyone building durable tooling, and it extends naturally to AI agents that call the CloudFormation API on your behalf, since such an agent can now read the stage status to reason about whether a phase is genuinely active. The one caveat to encode defensively is that operations predating the launch will not include the stages field, so check for its presence before parsing.

Stepping back to market context, this release reflects a broader and intensifying competition in the infrastructure as code space, and it is worth reading as a strategic signal rather than an isolated feature. Third-party tools like HashiCorp Terraform with its multi-account patterns, and Pulumi with its familiar programming-language approach, have long competed on developer experience and ecosystem breadth, and each has cultivated passionate communities around state management and provider coverage. What AWS is doing here is leaning into a structural advantage that no third party can easily replicate: native, deep integration with AWS Organizations, automatic cross-account role provisioning, and first-class awareness of service-managed deployment semantics. By improving the observability of StackSets rather than just its provisioning capability, AWS is closing the gap that historically pushed enterprises toward external tooling, namely the desire to understand distributed deployments without assembling a bespoke monitoring stack. The fact that this arrives at no additional charge, available wherever StackSets is supported, reinforces the platform-first strategy of making the native option good enough that the operational cost of leaving it outweighs the switching benefits. For platform teams weighing build-versus-buy for multi-account orchestration, that calculus just shifted meaningfully.

Translating all of this into practice, there are several concrete steps worth taking now. First, upgrade your tooling deliberately: the new fields require AWS CLI version 2, they are absent from version 1, and in code you need an SDK released on or after the November 2026 timeframe, so audit your CI runners, Lambda functions, and automation scripts to confirm you are not silently missing the data. Second, start instrumenting your pipelines to emit stage-level progress rather than relying on the top-level status alone, since a green operation status can now be interrogated for skipped or partially provisioned stages that deserve human attention. Third, build runbooks around the two-stage model, teaching your on-call engineers that role provisioning failures and deployment failures are distinct problems with distinct remedies, and that a success status paired with mass skips points to an upstream access or account-state issue. Fourth, if you are experimenting with AI-assisted operations, wire the stage status into your agents so they can make reasoned decisions about whether to wait, retry, or escalate. Finally, treat the regional breakdown as a first-class operational signal for capacity planning, since knowing whether Regions process in parallel or sequence helps you set realistic expectations for large rollouts and communicate them to the business before the work begins.