Quickstart

This guide walks through creating, designing, building, and deploying an Azure prototype from scratch. The full cycle takes roughly 15-30 minutes depending on project complexity.

1. Initialize the Project

Create a new prototype project with a workload template:

az prototype init --name contoso-webapp --location eastus --template web-app

This scaffolds a project directory, generates prototype.yaml configuration, and authenticates with your AI provider. The --template flag pre-populates services for the chosen workload pattern (web-app, serverless-api, microservices, ai-app, or data-pipeline).

 Authenticating with GitHub
 Authenticated as: jdavis
 Validating Copilot License
 Copilot license: enterprise

 Creating Project
 /home/jdavis/contoso-webapp

 Created files:
   prototype.yaml
   .gitignore

 ┌─ Project Initialized ─────────────────────┐
 │  Project:     contoso-webapp               │
 │  Location:    eastus                       │
 │  Environment: dev                          │
 │  AI Provider: copilot (claude-sonnet-4.5)  │
 │  IaC Tool:    terraform                    │
 │  Template:    Web Application (web-app)    │
 │                                            │
 │  Next: cd contoso-webapp && az prototype   │
 │        design                              │
 └────────────────────────────────────────────┘

Optional flags: --iac-tool bicep, --ai-provider github-models, --environment staging, --model gpt-4o.

2. Design the Architecture

Navigate into your project directory and start the design stage:

cd contoso-webapp
az prototype design

The design stage opens an interactive discovery conversation. A business analyst and cloud architect work together to understand your requirements, then generate a complete architecture. Answer questions about your use case, expected load, security needs, and integration points. Type done when you have covered enough ground.

After discovery completes, the extension produces architecture documentation, a service map, deployment plan, and cost estimates -- all saved under concept/docs/.

3. Build the Code

Generate infrastructure-as-code and application scaffolding:

az prototype build

The build stage reads your design artifacts and generates Terraform (or Bicep) modules and application code in staged groups. A QA engineer reviews the generated code for issues and triggers automatic remediation when problems are found. The final output lands in concept/infra/ and concept/apps/.

You can review and refine interactively -- the build session supports follow-up requests to adjust resources, add services, or fix specific files.

4. Deploy to Azure

Deploy the generated infrastructure and applications:

az prototype deploy

The deploy stage runs preflight checks (Azure login, subscription, required tools), shows a deployment plan, then executes each stage sequentially. Use --dry-run to preview what would happen without making changes. If a stage fails, the QA engineer diagnoses the issue and suggests fixes.

# Preview without deploying
az prototype deploy --dry-run

Deployment supports --subscription, --tenant, and service principal authentication for CI/CD scenarios.

5. Check Status

View the current state of your project at any time:

az prototype status

This shows which stages have been completed, the AI provider in use, configured services, and any pending actions. Add --detailed for expanded information about each stage.

Next Steps

• Iterate on your design: Re-run az prototype design to refine requirements or add new services based on feedback.
• Generate a backlog: Use az prototype backlog generate to create user stories and push them to GitHub Issues or Azure DevOps.
• Explore configuration: Edit prototype.yaml to adjust naming strategies, add custom agents, or configure MCP tool servers.
• Stage-specific guides: See Design, Build, and Deploy for in-depth documentation on each stage.