Blog Post

Azure Governance and Management Blog
10 MIN READ

A year of Azure Deployments: highlights from 2026

torreyt's avatar
torreyt
Icon for Microsoft rankMicrosoft
Nov 16, 2026

Ahead of the Bicep Ignite Special on November 19, here's a look back at what shipped this year across Bicep, Deployment Stacks, bicep-deploy, the Bicep MCP server, and Azure Verified Modules.

This year we had a lot of highlights to celebrate - we put out more than ten Bicep releases, What-If for Deployment Stacks went GA, the Bicep MCP server got new tools, and the Azure Verified Modules team joined us.

A lot of these features started as GitHub issues, community call questions, or "why can't I just..." comments at conferences. So before anything else - thank you to our community. If you filed an issue, sent a PR, or challenged us on syntax during a community call, you played a part in improving Azure deployments for everyone.

1. Deployment Stacks: see what's going to be deleted before you delete it

1.a. What-If for Deployment Stacks is generally available.

Stacks What-If shows you what a stack deployment will create, modify, detach, or delete before you run it. It compares your template against the current state of the resources the stack manages, and filters out the differences that were already there after the stack's last deployment. In practice that cuts out most of the noise you've seen from regular deployment What-If. When we went GA, we were able to close out nearly 200 open What-If issues on GitHub, many of them noise reports.

It works across Azure CLI (az stack-whatif) and Azure PowerShell, at resource group, subscription, and management group scope.

You can also use Stacks What-If to find configuration drift, i.e. changes made to a stack's resources outside the stack since its last deployment: Use what-if to investigate configuration drift

Why it matters: you can finally use Stacks for real lifecycle management, including deletes, with a reviewable preview in your PR. If you've been running Stacks in detach mode "just to be safe," this is your sign to try delete.

Docs: Preview deployment stack changes with what-if

2. Deploying from your pipeline: Bicep Deploy for GitHub Actions and Azure DevOps

The bicep-deploy GitHub Action handles both regular deployments and Deployment Stacks, with create, validate, whatIf and (for stacks) delete operations, from one GH action. This year it picked up Stacks What-If support, better What-If error handling and output fixes. It also checks up front that your template path points to a file, and your JSON parameters file exists, so you get a clear failure instead of a confusing one halfway through a run.

- name: Preview stack changes
  uses: azure/bicep-deploy@v2
  with:
    type: deploymentStack
    operation: whatIf
    name: platform-stack
    scope: resourceGroup
    subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    resource-group-name: rg-platform
    template-file: ./main.bicep
    parameters-file: ./main.bicepparam
    action-on-unmanage-resources: delete
    deny-settings-mode: none

We also added support for Azure DevOps this year with the BicepDeploy@0 task. It shares a library (bicep-deploy-common) with the GitHub Action, so the behavior and functionality should feel familiar across both tools. New features can reach the two tools at different times.

Why it matters: "What-If on every PR, deploy on merge" is now a few lines of YAML, and the action works the same way for stacks and deployments.

Docs: Deploy Bicep files by using GitHub Actions · BicepDeploy@0 task · Repo: github.com/Azure/bicep-deploy

3. Parameter files that scale with your environments

3.a. Extendable parameter files (GA)

If you have dev, test, and prod, you probably have three .bicepparam files that are 90% identical. Extendable params let you put the shared values in one file and override only what's different:

// shared.bicepparam
using none

param namePrefix = 'contoso'
param location = 'westus3'
// dev.bicepparam
using './main.bicep'
extends './shared.bicepparam'

param namePrefix = 'contoso-dev'   // overrides the shared value

Inherited parameters are also optional now. Your shared file can hold values that not every template uses, without the compiler complaining. This means when a parameter changes you don’t have to remember to change it in three places - change it in one place and get the benefit across environments.

Docs: Extendable parameter files in Bicep

3.b. bicepconfig.json inheritance

A bicepconfig.json can now extend another config file and override only the settings it cares about. Platform teams can define one org-wide baseline (linter levels, registry aliases, and so on) and have every repo inherit it:

{
  "extends": "../shared/bicepconfig.base.json",
  "analyzers": {
    "core": {
      "rules": {
        "no-hardcoded-env-urls": { "level": "error" }
      }
    }
  }
}

Docs: Bicep configuration inheritance

Why it matters: less copy-paste, less drift between environments, and one place to change a setting instead of thirty repos.

4. Language features: fewer workarounds, fewer failed deployments

4.a. @nullIfNotFound() and the this namespace (GA)

"Deploy this if it doesn't exist, otherwise reference it" used to mean deployment scripts or parameters passed in from the pipeline. Now:

@nullIfNotFound()
resource kv 'Microsoft.KeyVault/vaults@2023-07-01' existing = {
  name: keyVaultName
}

output kvUri string = kv.?properties.vaultUri ?? 'not deployed yet'

The this namespace lets a resource look at its own current state. this.exists() returns a bool, and this.existingResource() returns the resource if it's there or null if it isn't:

resource sa 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku: { name: 'Standard_LRS' }
  properties: {
    // keep whatever TLS setting is already on the resource; default new ones to 1.2
    minimumTlsVersion: this.existingResource().?properties.minimumTlsVersion ?? 'TLS1_2'
  }
}

We also added runtime values in tags and sku as an experimental feature, so a redeploy can keep the values that are already on a resource instead of stomping them. As the experimental features doc notes, it won't work until the backend support is deployed.

Docs: @nullIfNotFound() · The this namespace

4.b. @retryOn() (GA)

Some deployments fail on transient errors that succeed on a second try. Instead of wrapping your whole pipeline in retry logic, you can now retry just the resource that needs it, on just the error codes you expect:

@retryOn(['ResourceNotFound'], 10)
resource storageAccount 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: 'srp1'
  location: location
  sku: {
    name: 'Premium_LRS'
  }
  kind: 'BlobStorage'
}

Docs: Retry resource deployments in Bicep

4.c. Resource provider registration (experimental)

With the azExtensionConfig experimental feature, a template can list resource provider namespaces in the providers property of the az extension. ARM then registers each one on the target subscription at the start of the deployment. It registers resource providers only, not preview features. As the experimental features doc notes, it won't work until the backend support is deployed.

extension az with {
  providers: [
    'Microsoft.Storage'
    'Microsoft.Compute'
  ]
}

4.d. New functions: like(), distinct(), roleDefinitions(), getRoleAssignmentName()

Each one replaces something people were hand-rolling:

output isProd bool = like(environmentName, '*prod*')      // wildcard matching
output regions array = distinct(['eastus', 'westus', 'eastus'])

properties: {
  roleDefinitionId: roleDefinitions('Storage Blob Data Reader').id   // look up built-in roles by name, no more GUIDs
  principalId: identity.properties.principalId
}

getRoleAssignmentName() gives role assignments a deterministic name, which helps a lot with the "duplicate role assignment" errors you hit when different tools name the same assignment differently.

Docs: like() · distinct() · roleDefinitions() · getRoleAssignmentName()

4.e. Multi-line interpolated strings (GA)

Embedding a script, a policy rule, or a chunk of JSON in a template no longer means a wall of concat() or escaping:

var policyRule = $'''
{
  "if": { "field": "tags['${tagName}']", "exists": "false" },
  "then": { "effect": "${policyEffect}" }
}
'''

Docs: Multi-line strings

4.f. Extension namespace functions

Extension authors can now ship typed functions for .bicepparam files. You declare the extension in the parameters file and call its function, for example something like ext.config('redis'), instead of writing raw externalInput() calls and memorizing the expression format. Bicep checks the arguments against the types the extension publishes, then turns the call into an externalInput() request, and the tool that runs the deployment supplies the value.

Docs are on the way. For now, see externalInput().

Why it matters: most of these remove a reason to drop out of Bicep into a script. Fewer scripts means fewer moving parts, and deployments that are easier to reason about.

5. Tooling: Console, Snapshot, Visualizer, and friends

5.a. Bicep Console (GA)

bicep console is a REPL for Bicep expressions. It's the fastest way to check what a function returns without deploying anything (functions that need Azure context, such as resourceGroup(), don't work there). Since it went GA, it has added Home and End keys, word-by-word cursor jumps, and undo/redo. It also supports the load*() functions, and you can pipe input into it:

echo "parseCidr('172.18.0.0/20')" | bicep console

Docs: bicep console

5.b. Snapshot (GA)

bicep snapshot produces a normalized, fully evaluated view of what a .bicepparam file will deploy. You commit it, and on the next change you validate against it. The diff shows exactly which resources and properties moved, all locally with no Azure connection:

bicep snapshot main.bicepparam --mode overwrite   # capture
bicep snapshot main.bicepparam --mode validate    # compare against the last snapshot

You can also pass subscription, resource group, and location to evaluate with real deployment context. This is great for refactoring: if the snapshot doesn't change, your refactor didn't change what gets deployed.

Docs: Test Bicep changes with snapshots

5.c. A rebuilt Visual Designer

The visualizer got rebuilt. The language server now builds the graph and lays it out (with MSAGL), and you can collapse modules, export the graph as a PNG, and use high-contrast themes. Resources with errors are marked on the graph, and you can undo or redo node moves and layout changes. An experimental setting (bicep.visualizer.experimental.enableResourceEditing) also lets you add resources from a palette, which lists only the resource types that can deploy at the file's target scope.

Docs: Open Bicep Visualizer command. Docs for the new designer features are on the way.

5.d. Bicep Playground redesign

The Playground got a new look. Compilation moved off the main thread, so the UI doesn't freeze, and you now get diagnostics and light/dark themes. It's a nice way to try a feature or share a repro without installing anything.

Try it: Bicep Playground

5.e. Module documentation generation (experimental)

bicep docs generate builds Markdown docs for a module from the Bicep code itself. This came straight out of AVM, which needed a way to drop a pile of custom PowerShell. It's also something module authors have been asking for, for a long time.

bicep docs generate ./main.bicep
bicep docs generate --pattern './modules/**/main.bicep'

Docs: Generate module documentation

5.f. Language server as a standalone tool

The Bicep language server is now published as a .NET tool, so you can run it outside VS Code in Neovim, Emacs, or whatever your editor of choice is:

dnx -y Azure.Bicep.LangServer

Docs: Bicep language server .NET tool

5.g. Faster CLI

We spent time on performance this year: caching fixes in the compiler and language server, plus ReadyToRun compilation to bring CLI cold-start times down. In our benchmark on Windows x64, a cold bicep build went from about 3.6 seconds to 1.3. If you run bicep build in CI, you'll notice.

Details: v0.47.16 release notes

5.h. New linter rules

A batch of new rules catches mistakes while you're authoring instead of at deploy time, including:

Docs: Use Bicep linter

6. Bicep MCP server

If you're writing Bicep with GitHub Copilot or another agent, the Bicep MCP server gives the model tools for Bicep generation. It can fetch the schema for a resource type and API version, get Bicep best practices, list Azure Verified Modules metadata, build a file and return its diagnostics, format a file, decompile ARM JSON, and generate a deployment snapshot from a .bicepparam file. The model can check its own work against the compiler before it hands anything back to you.

It ships in the VS Code Bicep extension, and you can run it with any MCP-capable client (it needs the .NET 10 SDK):

dnx -y Azure.Bicep.McpServer

We also published the core library (Azure.Bicep.McpServer.Core) so you can build your own remote MCP server on top of it.

Why it matters: AI-generated Bicep that compiles, uses real API versions, and follows best practices on the first try.

Docs: Bicep MCP server. We'd also love your feedback on how you use Bicep with AI: aka.ms/BicepwithAI

7. Modules, registries, and samples

7.a. OCI registry support (experimental)

You're no longer tied to Azure Container Registry for publishing and consuming modules and extensions. With the ociEnabled experimental feature turned on, bicep publish can target any OCI registry, such as GitHub Container Registry:

bicep publish ./main.bicep --target br:ghcr.io/myorg/modules/storage:v1

Docs: Using OCI registries (experimental)

7.b. Azure Verified Modules joined the team

AVM moved into Azure engineering and is now part of the Azure Deployments team. AVM stays open source, and now has more investment behind it. We also restarted the AVM community call and published the Avm.Authoring PowerShell module for module authors. For more, see the AVM announcement and the October AVM community call recording.

Docs: Azure Verified Modules

7.c. Bicep and Terraform samples in the template reference

The Azure template reference docs now include Bicep and Terraform samples. You can look up a resource type and find an example in the language you use, not just ARM JSON.

Docs: Azure template reference

8. Azure Blueprints is retiring: move to Deployment Stacks

Azure Blueprints (preview) retires on January 31, 2027, and the phased retirement has already started. Deployment Stacks, along with Template Specs for versioning, is the replacement. Most of what Blueprints did maps cleanly:

  • Artifacts become ARM or Bicep templates.
  • Locks become deny settings.
  • Assignment lifecycle becomes stack lifecycle, and now you get What-If too.

If you're still on Blueprints, start now. Migration guide: Migrate blueprints to deployment stacks · Retirement details: aka.ms/AzureBlueprintsRetirement

Stay in touch

We'll walk through these highlights live in the Bicep Ignite Special on Thursday, November 19 at 9:00 AM PT. If you want to follow along with the demos, the code is in github.com/SydneyhSmith/ignite2026-demo.

After that, join us for the next Bicep community call on Wednesday, December 2 at 9:00 AM PT, and sign up for community call invites at aka.ms/AzureBicep.

Tell us what's working and what isn't. Open an issue in Azure/bicep, Azure/deployment-stacks, or Azure/bicep-deploy, and share how you use Bicep with AI at aka.ms/BicepwithAI. For news between calls, follow @BicepLang on X and biceplang.bsky.social on Bluesky.

Updated Nov 16, 2026
Version 1.0