Generated banner for Azure Enterprise Infra Planner
Generated logo for Azure Enterprise Infra Planner

Azure Enterprise Infra Planner

MicrosoftOfficialCreated by Microsoft

  • Skill
  • Workflow
  • Cloud and DevOps
  • MIT
  • No issues found

From the author

Architect and provision enterprise Azure infrastructure from workload descriptions. For cloud architects and platform engineers planning networking, identity, security, compliance, and multi-resource topologies with WAF alignment. Generates Bicep or Terraform directly (no azd). WHEN: 'plan Azure infrastructure', 'architect Azure landing zone', 'design hub-spoke network', 'plan multi-region DR topology', 'set up VNets firewalls and private endpoints', 'subscription-scope Bicep deployment', 'Azure Backup for VM workloads'. PREFER azure-prepare FOR app-centric workflows.
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill guides users through a 7-phase pipeline to design and deploy Azure infrastructure. It processes workload descriptions to generate Bicep or Terraform code, supporting both greenfield deployments and additive updates to existing environments. The process includes research, planning, user approval, and automated validation using security and syntax checks before deployment.

What it does

  • Extracts insights from workload descriptions to inform infrastructure planning.
  • Researches Azure best practices and service-specific documentation.
  • Generates infrastructure plans and corresponding Bicep or Terraform code.
  • Validates generated IaC using syntax checks and security scanning tools.
  • Supports additive deployments for existing environments without modifying referenced resources.
  • Manages multi-resource topologies including networking, identity, and compliance configurations.

When to use it

  • When planning Azure infrastructure from a workload or architecture description.
  • When designing hub-spoke networks, landing zones, or multi-region topologies.
  • When setting up networking components like VNets, firewalls, and private endpoints.
  • When generating subscription-scope or multi-resource-group infrastructure code.

Advantages

  • Follows a structured, gated pipeline to ensure plan approval and code validation.
  • Integrates security scanning and syntax validation into the generation workflow.
  • Provides support for referencing existing resources to avoid accidental recreation.
  • Utilizes specific Azure schema data to ensure accurate resource definitions.

Usage examples

“Plan Azure infrastructure for a hub-spoke network with firewalls.”
The agent initiates the 7-phase pipeline, researching networking best practices and generating the corresponding IaC for the requested topology.
“Architect an Azure landing zone.”
The agent guides the user through requirements extraction and resource planning, resulting in a structured infrastructure plan and Bicep or Terraform files.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/azure-enterprise-infra-planner/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip azure-enterprise-infra-planner.zip -d .agents/skills

Documentation by Microsoft

Azure Enterprise Infra Planner

When to Use This Skill

Activate this skill when user wants to:

  • Plan enterprise Azure infrastructure from a workload or architecture description

  • Architect a landing zone, hub-spoke network, or multi-region topology

  • Design networking infrastructure: VNets, subnets, firewalls, private endpoints, VPN gateways

  • Plan identity, RBAC, and compliance-driven infrastructure

  • Generate Bicep or Terraform for subscription-scope or multi-resource-group deployments

  • Plan disaster recovery, failover, or cross-region high-availability topologies

Quick Reference

PropertyDetails
MCP toolsinsights_get, get_azure_bestpractices_get, wellarchitectedframework_serviceguide_get, microsoft_docs_fetch, microsoft_docs_search, bicepschema_get
CLI commandsaz deployment group create, az bicep build, az resource list, terraform init, terraform plan, terraform validate, terraform apply, checkov
Output schemaschema.md
Key referencesworkflow.md, waf-checklist.md, resources/, constraints/

Workflow (Start Here)

Follow the step-by-step instructions in workflow.md to execute the 7 phases of infrastructure planning and provisioning.

Architecture

The skill runs a 7-phase, gated pipeline. Input is triaged into one of two flows:

  • Greenfield — only new requirements; run the phases straight through.

  • Referenced (brownfield) — the user supplies something that already exists (a live resource / resource group / subscription, IaC or an infra plan, or a requirements doc). The same phases run, plus referenced-workload.md: existing resources are inventoried and referenced (never recreated), the new workload is wired into them, and Phase 7 deploys additively (incremental only — never modifying or destroying the referenced resources).

Every phase advances only after its gate passes. Phase 5 requires explicit user approval; Phase 6 is a hardened, self-verifying gate — the generated IaC must be secure-by-default, pass local validation (az bicep build / terraform validate) with zero errors, pass a checkov security scan with no unresolved high/critical findings, and the skill must show the command output and emit a completion self-check before advancing; Phase 7 requires an explicit, risk-acknowledged deploy confirmation.

flowchart TD
    IN([Input]) --> TRIAGE{Existing infra<br/>referenced?}
    TRIAGE -- "No (greenfield)" --> P1
    TRIAGE -- "Yes (referenced)" --> RW[/referenced-workload.md:<br/>inventory + assign roles<br/>reference, never recreate/]
    RW --> P1

    subgraph PIPE [7-phase gated pipeline]
        direction TB
        P1[Phase 1 · Extract insights] --> P2[Phase 2 · Research best practices]
        P2 --> P3[Phase 3 · Research resources]
        P3 --> P4[Phase 4 · Generate plan]
        P4 --> P5{Phase 5 · Verify<br/>user approves?}
        P5 -- "no" --> P4
        P5 -- "approved" --> P6[Phase 6 · Generate IaC]
        P6 --> VAL{Validate<br/>az bicep build /<br/>terraform validate}
        VAL -- "errors" --> P6
        VAL -- "clean" --> P7{Phase 7 · Deploy<br/>risk-ack confirm?}
    end

    P7 -- "greenfield" --> DEP[az deployment / terraform apply]
    P7 -- "referenced" --> DEPADD[Additive deploy · incremental only<br/>what-if preview · no destroy of<br/>referenced resources]
    DEP --> OUT([Deployed])
    DEPADD --> OUT

    classDef gate fill:#fff3cd,stroke:#d39e00,color:#000;
    classDef ref fill:#e2f0d9,stroke:#548235,color:#000;
    class P5,VAL,P7,TRIAGE gate;
    class RW,DEPADD ref;

Artifacts (written under <project-root>/): .azure/insights.json (Phase 1), .azure/infrastructure-plan.json (Phase 4, status draft→approved→deployed), and infra/main.bicep + infra/modules/* or infra/main.tf + infra/modules/** (Phase 6).

MCP Tools

ToolPurpose
insights_getRetrieve insights about the user's existing Azure environment to guide planning decisions
get_azure_bestpractices_getAzure best practices for code generation, operations, and deployment
wellarchitectedframework_serviceguide_getWAF service guide for a specific Azure service
microsoft_docs_searchSearch Microsoft Learn for relevant documentation chunks
microsoft_docs_fetchFetch full content of a Microsoft Learn page by URL
bicepschema_getBicep schema definition for any Azure resource type (latest API version)

Error Handling

ErrorCauseFix
MCP tool error or not availableTool call timeout, connection error, or tool doesn't existRetry once; fall back to reference files and notify user if unresolved
Plan approval missingmeta.status is not approvedStop and prompt user for approval before IaC generation or deployment
IaC validation failureaz bicep build or terraform validate returns errorsFix the generated code and re-validate; notify user if unresolved
Pairing constraint violationIncompatible SKU or resource combinationFix in plan before proceeding to IaC generation
Infra plan or IaC files not foundFiles written to wrong location or not createdVerify files exist at <project-root>/.azure/ and <project-root>/infra/; if missing, re-create the files by following workflow.md exactly

Files

references/schema.md

Infrastructure Plan Schema

{
  meta: {
    planId: string // Unique identifier (e.g., "plan-1")
    generatedAt: string // ISO 8601 timestamp
    version: string // Schema version (e.g., "0.1-draft")
    status: "draft" | "approved" | "deployed" // Lifecycle state
  }
  inputs: {
    userGoal: string // User's stated objective or workload description, matches user query exactly
    subGoals?: string[] // Inferred architectural constraints and priorities derived from the user's request and research phase. Examples: "Cost-optimized: user chose defaults, avoid premium networking", "Security-first: encrypt all data, use managed identity", "Minimal complexity: single region, no VNet". These help evaluators understand intentional tradeoffs. Should be short list of 0-3 points.
    insightsApplied: string[] // For each insight that influenced this plan, cite the insight ID and explain how and why it was applied. Set to an empty array if no insights were applied. Document any unapplied insights in plan.overallReasoning.tradeoffs.
  }
  plan: {
    resources: {
      name: string // Logical resource name (CAF-compliant)
      type: string // ARM resource type (e.g., "Microsoft.Storage/storageAccounts")
      subtype?: string // Exact subtype (e.g., "Blob Storage", "Azure Function")
      location: string // Azure region (e.g., "eastus")
      sku: string // SKU tier (e.g., "Standard_LRS", "Consumption")
      properties?: Record<string, unknown> // Resource-specific properties
      reasoning: {
        whyChosen: string // Justification referencing WAF pillars (see phases/2-research-best-practices.md and phases/3-research-resources.md) or requirements
        alternativesConsidered: string[] // Other options evaluated
        tradeoffs: string // Key tradeoffs in this choice
      }
      dependencies: string[] // Names of resources this depends on (empty if none)
      dependencyReasoning?: string // Why these dependencies exist
      references: { title: string, url: string }[] // Links to Azure docs
    }[]
    overallReasoning: {
      summary: string // Overall architecture rationale
      tradeoffs: string // Top-level tradeoffs and gaps
    }
    validation: string // Deployment coherence statement
    architecturePrinciples: string[] // Guiding principles (e.g., "Highly available", "Secure")
    references: { title: string, url: string }[] // Architecture-level doc links
  }
}

Insights Schema

type ExistingResource = {
  id: string // Full ARM ID for actual state; logical or parameter reference otherwise
  type: string // ARM resource type (e.g., "Microsoft.Network/virtualNetworks")
  name: string
  role: "reference-and-integrate" | "retain" | "ignore"
  must_not_recreate: true
  integrationPoints: string[] // Connections or dependencies involving the new workload
}

type Insight =
  | {
      id: string // Stable identifier (e.g., "insight-001"); cited from inputs.insightsApplied
      pattern: string // Observed fact from the tenant scan or referenced workload
      implication: string // Recommended planning action derived from the pattern
      existingResource?: ExistingResource
    }
  | {
      id: string // Stable identifier for a resource-only entry
      existingResource: ExistingResource
      pattern?: string // Include with implication when the resource produces a broader insight
      implication?: string
    }

type Insights = Insight[]

In referenced mode:

  • Include exactly one entry for every inventoried existing resource, uniquely identified by existingResource.id.

  • Preserve the full ARM ID in existingResource.id for actual-state resources.

  • Use an empty integrationPoints array when the resource has no integration points.

  • A resource-only entry may omit pattern and implication; when recording a broader insight, include both.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills · .github/plugins/azure-skills/skills/azure-enterprise-infra-planner · commit 0696600
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from .github/plugins/azure-skills/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
microsoft/azure-skills

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download azure-enterprise-infra-planner.zip