
Vibe coding apps on Azure safely comes down to 7 steps and a short production checklist. I went through Microsoft's tutorials, docs, and 2 engineer-written walkthroughs to map the steps, the tools, and the governance IT needs.
What is vibe coding on Azure?
Vibe coding on Azure is building an app by describing it in plain language to an AI agent, then letting the agent write, fix, and deploy the code to Azure.
Andrej Karpathy coined the term for coding through natural-language prompts, per Superblocks' guide to vibe coding security, which also covers what happens when that code reaches production without IT review.
On Microsoft's stack, the agent is GitHub Copilot in VS Code, and Microsoft Learn's 9-unit Introduction to vibe coding module is centered on it.
The enterprise work starts after the prototype runs. A production app on Azure needs sign-in, secrets management, logging, and a deployment pipeline.
Microsoft documents each of those pieces separately from its vibe coding walkthroughs, so this guide puts them in one sequence.
What you'll need before starting
Line up the accounts and permissions below before Step 1, starting with the Azure subscription and the Entra ID rights, since IT grants both.
Prerequisites:
- An Azure subscription with permission to create resource groups (ask IT for a sandbox subscription if you don't have one)
- A GitHub account and a GitHub Copilot plan (Free covers agent mode; assigning issues to the cloud agent in Step 4 needs Copilot Student or a paid plan)
- Visual Studio Code with GitHub Copilot (signing in installs the extensions it needs)
- A model deployed in Microsoft Foundry (only if your app calls an LLM)
- Rights to register apps in your Microsoft Entra ID tenant (or an admin who can do it for you) for the sign-in setup in Step 5 and the production checklist
Time required: A simple prototype can reach Azure in a single working session if you already have subscription access.
Submit your access requests (subscription, Entra app registration, repo permissions) before you start, since you can't deploy (Step 6) or test sign-in without them.
How to vibe code an app on Azure: step-by-step
The steps follow the order Microsoft's walkthroughs use. Write the spec in Step 2 before anything else, because without it you'll likely end up rewriting the app.
Step 1: Set up the environment
Install VS Code and set up GitHub Copilot by signing in with your GitHub account. GitHub's install instructions say the required extensions install during setup, and you get Copilot Chat access with them.
Then open the chat pane and switch the mode to Agent, which lets Copilot edit files, run terminal commands, and iterate on its own output.
For Azure deployment, Microsoft's agent mode quickstart uses the GitHub Copilot for Azure tools, including "Run AZD Up to deploy to Azure" and "Configure Azure deployment pipeline." Turn those tools on now so Step 6 can use them.
If your app needs an LLM, deploy a model in Microsoft Foundry (formerly Azure AI Foundry, and before that Azure AI Studio, per Microsoft's migration page).
For reference, the author of Microsoft's September 2025 Translator web app walkthrough, which Steps 3 and 4 draw on, ran Copilot's agent mode on GPT-5 (Preview) through Azure OpenAI.
Sandbox rule: Use a dedicated sandbox resource group, because agent mode can create Azure resources as it works.
azd down deletes the resources the azd template created, so anything the agent created another way can stay behind. Check the resource group in the portal before and after each agent session.
Step 2: Write a spec and an instructions file
Before the first prompt, write down what the app does, who uses it, which data it touches, and what the screens look like.
Microsoft's Marco Casalaina calls this structured vibe coding. His spec listed the agents, the tools each could use, how workflows ran, and a screenshot of the UI he wanted.
Then give Copilot standing rules. VS Code reads custom instructions from .github/copilot-instructions.md at the repo root and includes it by default (with the instruction-files setting on).
For specific folders, add .instructions.md files with an applyTo pattern. A short starting file for an Azure internal app:
# Project rules
- Stack: .NET 10 (LTS) web app, deployed to Azure App Service.
- Never put secrets, keys, or connection strings in code or appsettings.json.
Read them from environment variables backed by Azure Key Vault.
- Use parameterized queries only.
- Authentication is handled by App Service with Microsoft Entra ID. Don't build login pages.
- Every new endpoint gets a unit test.
The file pins .NET 10 because it's supported until November 14, 2028, and Microsoft ended .NET 8 support on November 10, 2026.
Why it matters: VS Code sends these rules with your requests, so you stop repeating "don't hardcode the key" in every prompt. Copilot can still drift from them, so review the output anyway.
Step 3: Describe the app in plain language
Now write the core prompt like a ticket, with the inputs, the limits, what happens on click, and what the page shows after.
The Translator walkthrough is a good model. Its prompt asked for a .NET web app with a source text box capped at 5,000 characters and lists of source and target languages. Optional fields let the user pick a model, gender, and tone.
It also asked for a REST call to the Translator API, with a sample curl command pasted in as reference.
The pasted curl showed the agent the request format. It didn't show the response headers, and that's where the agent guessed wrong, as Step 4 shows. Paste the contract for both the request and the response, and the agent has less to guess.
Pro tip: In the Translator walkthrough, the agent "took confirmation from me at every stage," the author wrote. Each confirmation is your chance to catch a wrong framework or a missing field early.
Step 4: Refine it through prompts and issues
Expect the first version to miss on a few details. Fix it with short, single-purpose prompts, like "keep source language and target language side by side" or "collapse the raw response by default."
Small prompts also make wrong guesses easy to spot. In the Translator walkthrough, the agent invented response header names (x-metered-usage, x-source-tokens, x-target-tokens) that the Translator API didn't return.
Two one-line corrections fixed them, the first for the character-count header and the second for both token headers.
For bigger changes, move to GitHub issues. Casalaina filed an issue per improvement and assigned each one to the Copilot coding agent. Then he checked the draft pull requests (PRs) it opened, with 3 coding agents working at once.
Watch your keys: Never type live keys into prompts or into source-controlled files like appsettings.json. The Translator author kept keys out of the chat by editing the connection settings by hand in that file.
For a company app, keep them out of the file too, with user secrets or environment variables locally and Key Vault in Azure.
Step 5: Test it
Run the app locally, click through every path, and then ask Copilot to write tests for the code it just wrote. Read the diff before you accept it, the same way you'd check a teammate's PR.
Casalaina ran his test suite and scanned the diffs before merging his agents' PRs. That cycle (spec, issues, PRs, review) leaves an issue and a reviewed PR behind each change.
App Service authentication has no local emulator, and Microsoft's Entra auth tutorial says you have to deploy to test the sign-in flow. Test sign-in after Step 6, on a staging deployment.
Before you merge, ask Copilot to list every external call and every place it reads a secret, then check anything you didn't ask for.
Step 6: Deploy it to Azure
In agent mode, send the prompt Microsoft uses in its quickstart: "Help me deploy my project to Azure." Copilot analyzes the project, generates Bicep files and an azd template, runs pre-deployment checks, then starts azd up in the VS Code terminal.
azd up asks for an environment name and a resource group. If the deploy fails (Microsoft's quickstart warns you might hit a .NET version error), Copilot can attempt the fix and redeploy.
Read the generated Bicep before you approve it, since it sets the App Service plan, the region, and the networking, and all 3 appear on your Azure bill.
Microsoft notes that responses vary between runs, so if Copilot picks an Azure service you didn't expect, ask what it plans to do before it continues.
Step 7: Set up CI/CD with GitHub Actions
Run azd pipeline config from the project root, choose GitHub as the provider, and pick your subscription and region. According to Microsoft's azd pipeline docs, pushing a commit then triggers the GitHub Actions pipeline to provision and deploy your changes.
By default, the command sets up OpenID Connect (federated credentials), so no long-lived Azure secret sits in GitHub.
Keep in mind the command is still in beta. Microsoft also lists OIDC as unsupported for Terraform, so Terraform projects fall back to --auth-type client-credentials.
Pro tip: Add a required review on the main branch before you turn the pipeline on. Otherwise, an agent's PR deploys to Azure as soon as someone merges it.
Vibe coding options on Microsoft's stack and when to use each
Azure teams have 4 options, and they do different jobs. Copilot, Power Apps, and Replit generate apps, and Foundry supplies the models those apps call.
GitHub Copilot
GitHub Copilot is the default choice for vibe coding on Azure if your builders can read code.
Agent mode is included on every plan, including Free, and Copilot cloud agent (formerly the coding agent, which takes assigned issues) starts on Student and paid plans.
Pro is $10 per month, Pro+ is $39 per month, and Max is $100 per month. Each plan comes with a monthly allotment of GitHub AI Credits, so agent use isn't unlimited.
For companies, GitHub's plans docs list Copilot Business at $19 per granted seat per month and Enterprise at $39 per granted seat per month.
Microsoft Foundry
You deploy and govern your app's models in Foundry. Use it for apps that call a model at runtime, like the Translator walkthrough.
Copilot is a separate decision. It keeps using GitHub's model list until you point it at your own model with the bring-your-own-key setting, which your plan and your org's policies control.
Pricing depends on the model, the deployment type, and your usage, so budget per workload.
Power Apps vibe experience
The Power Apps vibe experience turns a prompt into requirements and a data model, then generates the app's code. It's aimed at "business analysts, citizen developers, and professional developers" building line-of-business apps.
It's still a preview, with hard limits: no default environments, English only, and only the US, Australia, Asia, and India regions.
The same page says app building is now available in Copilot Cowork and coming to Copilot Studio, and Microsoft recommends those going forward. Plan for the vibe experience to change, and note that a Premium license doesn't lift the preview limits.
Power Apps Premium is $20 per user/month, paid yearly. Microsoft lists no month-to-month price on the page, and a 2,000-seat minimum drops it to $12 per user/month, paid yearly.
Replit on Azure
Replit is the option for business users who build by prompt and want the app deployed to Azure.
The company announced a partnership with Microsoft in July 2025 covering deploys to Azure Container Apps, Azure Virtual Machines, and Neon Serverless Postgres on Azure, with Azure Marketplace purchasing planned for later.
That was the announced scope, so ask Replit which pieces your tenant can use today.
Core is $20 per month, billed monthly, or $18 per month billed annually. Pro starts at $100 per month, billed monthly, and Enterprise (custom pricing) adds SSO, SCIM, and audit logs.
What a vibe-coded app needs before it goes to production on Azure
A vibe-coded app is ready for internal production on Azure when it signs users in with Entra ID, logs centrally, runs on managed hosting, keeps secrets out of code, and passes its tests in CI. Apps exposed outside the company also need an API gateway and extra checks.
innFactory's enterprise guide for IT leaders lists 6 design principles every vibe-coded app must meet before production, plus a separate maturity model for prioritizing. Each principle maps to an Azure service:
- Single sign-on with Entra ID: Turn on App Service authentication. In Microsoft's tutorial, the back end rejects unauthorized calls with a 401 "before the request reaches your application code."
App Service auth handles sign-in. Add authorization checks in the app so each signed-in user opens only their own records.
- Central logging and monitoring: To see failures before users report them, send telemetry to Application Insights in Azure Monitor and watch for unhandled exceptions, failed requests, and slow dependency calls.
Sign-in failures live in Entra ID's sign-in logs, so route those to the same workspace.
- Managed hosting: Run the app on App Service, Azure Container Apps, or another managed host in a subscription IT owns, so it stays off personal accounts and laptops.
- Secrets kept out of code: Store secrets in Key Vault and point app settings at them with @Microsoft.KeyVault(SecretUri=...), per the Key Vault references article.
Then give the app's managed identity the Key Vault Secrets User role (Azure RBAC vaults) or the Get secret permission (access-policy vaults).
- An API gateway for external access: If customers, partners, or mobile users reach the app, put it behind Azure API Management and configure its policies for credential checks and rate limits.
innFactory's external production level adds this gateway, a penetration test, a data protection review, an SLA, and a security-focused code review.
- Tests in the pipeline: In the Step 7 pipeline, make tests and a SAST scan required checks.
Secrets deserve extra attention with any AI coding agent. GitGuardian's State of Secrets Sprawl 2026 found a 3.2% secret-leak rate in Claude Code-assisted public commits, against a 1.5% baseline across all public GitHub commits.
To keep that rate down, Superblocks walks through moving secrets into environment variables before the first commit.
How to govern vibe coding across the company
Governing vibe coding means IT can answer 4 questions about every app: who made it, what data it touches, who can access it, and when it last ran. Superblocks uses those exact questions as its governance test.
Once 10 departments have 50 apps between them, IT needs structure around how each one gets made.
Keep an approved app catalog
Start with a single registry of vibe-coded apps. innFactory's version records purpose, business owner, technical contact, maturity level (prototype through external production), data classification, and access model.
Tie the production URL to registration, so an app can't go live until it's in the catalog. Pair the catalog with the Application Insights logging from the production checklist, and IT can answer all 4 questions.
Assign roles and owners
Split ownership between IT and the business team. IT owns the subscription, pipelines, permissions, and standards, and the business team owns the app's requirements and acceptance testing.
Every app gets a named owner, so someone still answers for it after its builder changes jobs.
Stop shadow IT before it spreads
Shadow IT now starts with AI tools. Microsoft's 2024 Work Trend Index found 78% of AI users bring their own AI tools to work, and AI coding tools let that habit produce unapproved apps.
ShipBob's VP of IT and InfoSec counted 579 active Replit users in his company, per Superblocks. At that scale, people switch only when the approved option is faster than what they already use.
How Superblocks runs on Azure
Superblocks is an enterprise vibe coding platform where IT sets the guardrails. Business teams build apps by prompting Clark, its AI agent, inside rules IT configures once: RBAC and approved integrations, plus SSO and audit logs on Enterprise.
Superblocks documents 4 Azure pieces today, starting with where the data plane runs. The Hybrid model puts it in your own AWS, GCP, or Azure account, per the deployment overview.
On Azure, the Container Apps guide deploys it with 2 vCPUs and 4 GiB of memory, plus an optional dedicated VNet subnet for private databases.
Enterprise customers can set up Entra SSO, and a managed identity guide connects SQL Server on an Azure VM through Entra tokens, so no SQL password sits in Superblocks.
For tooling, the pricing page also lists Azure DevOps for source control and Azure Key Vault for secrets on Enterprise.
One deployment model is still unclear. The pricing page lists Azure for Cloud-Prem (the full platform, including AI inference, inside your cloud), but the deployment docs only describe the AWS build. Get Azure Cloud-Prem in writing from Superblocks before you plan around it.
Common mistakes to avoid
Each of these 5 mistakes skips one of the safeguards from the 7 steps, so check for them before your first deploy to Azure.
- Prompting before writing a spec: Without one, you get "prompt-and-pray" coding, Casalaina's term for taking whatever comes back and patching it by hand. Start with one page that covers users, data, and screens.
- Pasting live keys into the chat: Anything you paste stays in the chat history, and some services log prompts too. Use placeholder values and store the live ones in Key Vault.
- Storing data in a local SQLite file on hosting without persistent storage: If your spec doesn't name a database, check whether the agent picked SQLite.
Either give it persistent storage or move to a managed database like Azure SQL, Cosmos DB, or Azure Database for PostgreSQL. Pick based on how many users write at once and how you'll back it up.
- Trusting the generated Bicep blindly: The agent picks SKUs and regions, and a premium App Service plan in a region IT didn't approve still appears on your bill. Check both against your company's approved list before azd up.
- Letting the pipeline deploy unreviewed agent PRs: Turn on branch protection so a person approves each agent PR before it reaches production.
The limits of vibe coding on Azure
The approach has a ceiling, and Microsoft's Azure CTO ties it to project size.
In a 2025 Redmond keynote covered by GeekWire, Mark Russinovich said simple web apps and prototypes are within reach, while large projects with many interdependent files are "still beyond the capabilities of our AI systems."
He backed AI-assisted coding with humans in charge of architecture. It's a 2025 assessment, and the Microsoft walkthroughs above show the same pattern of small apps with a human reviewing every change.
So scope your first vibe-coded apps on Azure to things one team owns end to end, and have an engineer sign off on anything that touches a system of record.
How Superblocks handles governed vibe coding on Azure
Superblocks takes on the setup that repeats from app to app, so each new app starts with IT's rules already in place.
What Superblocks adds:
- Clark works within IT's rules: Builders describe the app in plain language, and Clark generates it with the RBAC rules IT already set (and SSO and audit policies on Enterprise).
- Production data stays in your Azure account (Enterprise): The Hybrid data plane runs in Azure Container Apps or Kubernetes in your network, so backend code executes next to your data.
Clark and the control plane stay in Superblocks Cloud and work with non-production data only.
- One queryable record of your apps: The Superblocks MCP and audit logs (Enterprise) record builder edits and deploys plus end-user activity and integration changes, so IT can see who made what and who has access.
- Export to code: Superblocks says apps can be exported as React code, so engineers can review what Clark generated.
According to its customer story, Virgin Voyages runs 15+ production apps made by non-engineers. Staff in 7+ departments use them, and the company has no dedicated frontend engineers.
Teams starts at $125 per month, billed monthly, or $100 per month billed annually.
It includes up to 15 builders, 100 Governed Agent Units per month, RBAC, staging and production environments, and 1 hosted app, with extra apps at $10 per app per month.
Enterprise uses custom pricing and adds SSO/SAML/OIDC, audit logs, and Hybrid or Cloud-Prem deployment in your VPC.
To see governed vibe coding on your own Azure data, book a demo or start the 14-day free trial of Teams. For the bigger rollout plan, read Superblocks' enterprise vibe coding best practices.
Frequently asked questions
These answers cover Microsoft's vibe coding tools, how vibe coding compares with AI coding, build times, and running Superblocks on Azure.
Does Microsoft have a vibe coding tool?
Yes, Microsoft has 2 vibe coding tools. Developers get GitHub Copilot agent mode in VS Code, and the Power Apps vibe experience (in preview) targets business users and makers building line-of-business apps. Microsoft Foundry sits behind them and hosts the models those apps call.
Is vibe coding still a thing?
Yes, vibe coding is still a thing, and it's moving into business workflows. Microsoft Learn now has a vibe coding training module, and Cloudsmith's 2026 research reports 93% of organizations have adopted AI-generated code, a wider category that includes vibe coding.
For the enterprise side, read what enterprise vibe coding is.
Is vibe coding just AI coding?
Vibe coding is one specific kind of AI coding. AI coding covers any AI help, like autocomplete, and vibe coding is the kind where you describe the app in plain language and let an agent write the bulk of the code.
Is vibe coding difficult?
Vibe coding small apps doesn't strictly require coding experience, per Microsoft's Translator walkthrough, and production takes more work. Coding skills still help you debug and spot wrong guesses like invented API headers.
How long does it take to vibe code an app on Azure?
A simple prototype can reach a running Azure URL in a single working session with GitHub Copilot and azd up. Production readiness (Entra ID, Key Vault, monitoring, CI/CD, security review) takes longer. Budget extra time for IT approvals and for each integration.
Can Superblocks run on Azure?
Yes. Superblocks runs its data plane in your Azure account with the Hybrid model (Azure Container Apps or Kubernetes). The pricing page also lists Azure for Cloud-Prem (the full platform in your own cloud); confirm the Azure Cloud-Prem build timeline with Superblocks, since the deployment docs currently walk through the AWS setup.
How do I move an app I built with another AI tool into Azure?
Rebuild it on managed Azure hosting with the production checklist above (Entra sign-in, Key Vault, Application Insights, CI). To keep IT’s rules in place from the start, Superblocks can import an app built with another AI tool and apply RBAC, SSO, and audit policy as it goes.
Stay tuned for updates
Get the latest Superblocks news and internal tooling market insights.
Request early access
Step 1 of 2
Request early access
Step 2 of 2
You’ve been added to the waitlist!
Book a demo to skip the waitlist
Thank you for your interest!
A member of our team will be in touch soon to schedule a demo.
production apps built
days to build them
semi-technical builders
traditional developers
high-impact solutions shipped
training to get builders productive
SQL experience required
See the full Virgin Voyages customer story, including the apps they built and how their teams use them.

"Those tools are great for proof of concept. But they don't connect well to existing enterprise data sources, and they don't have the governance guardrails that IT requires for production use."
Table of Contents

