When you’re part of an agile team, sometimes it feels like you’re orchestrating a heist. You’ve got a tight deadline, a complex
target, and a crew of specialists, each with their own quirks and talents. That’s exactly how it felt when I set out to
build a live .NET 10 Blazor Server sprint review dashboard for the team I work in at Intercept. But this time, my crew wasn’t just
my colleague; it was a team of AI agents assembled using GitHub Copilot’s Squad system, and each one had a name straight
out of Ocean’s Eleven.

Let me set the scene: Squad is a GitHub project that lets you assemble a named team of AI agents, each with a
persistent identity. For this job, I picked Ocean’s Eleven as my universe. The coordinator, Squad itself, was my Rusty
Ryan, keeping everyone in sync. My main developer agent? Livingston is named after Livingston Dell, the tech wizard who hacks
into the casino’s systems. The parallel was intentional and, honestly, delightful. Just like Danny Ocean briefs his crew for
a big job, I was Danny, briefing Livingston and the rest of the Squad for our sprint review dashboard caper.

Features I added include

• Main Dashboard as shown above
• Issues – show you a list of issues, sortable, filterbale and searchable for the previous, current and next sprint.
• Team Workload looks at how much work each team member has and shows you the % of open and closed tasks.
• Risks – this will highlight potential risks with the current workload / issue status’
• Members – shows you a view of each team memberm theire issues in previous, current and next sprint.
• Sprint Health – highlights serial carryover in issues, carried-over issues with no updates, and anything added mid-sprint.

The target: Project #134 for Team 503. The plan? Pull real data from the GitHub Projects API across three sprints, previous
(2026-4), current (2026-5), and next (2026-6). We needed an Issues page with a sortable, searchable table, complete with
GitHub issue links that open in a new tab. The Risks page would serve as our risk register, with linked issue-number badges.
The Team Workload page would show who’s carrying what, and the Members page would break down stats for each of our team
members, and the Sprint Health page would flag serial carry-overs (red), no-update carry-overs (yellow), and mid-sprint
additions (teal) so we could spot problems before they snowballed.

Here’s where the magic happened. Instead of slogging through days of solo development, I described the “job” to Livingston.
Features that would normally take hours, sometimes days, were done in minutes. Livingston even caught a subtle Blazor
gotcha with @rendermode InteractiveServer, making sure all filtering and searching was truly interactive. The Squad
coordinator orchestrated the operation, keeping everything on track.

But the real joy was in the pair programming experience. Instead of talking to a generic “AI assistant,” I was briefing my
crew. Livingston wasn’t just a bot, he was the tech guy, always ready to hack the next piece of the dashboard into
existence. The agent names made the whole process feel collaborative and fun, like we were all in on the heist together.

Looking back, this is how dev teams should work. Assemble your crew, brief them on the job, and let each specialist shine.
With Copilot Squad, the line between human and AI collaboration blurs in the best way. If you want to pull off your own
perfect sprint review heist, don’t just hire an assistant. Build a crew.

If you are interested this is how I went about it – I used https://bradygaster.github.io/squad and I cannot tell you just how impressive this is to use.

This application was built from scratch in a little over 30 minutes.

Ship faster

As developers, we’re always looking for ways to ship faster without sacrificing quality. The constant pressure to deliver new features while maintaining clean, maintainable code can feel like an impossible balance. But what if I told you that the latest wave of AI tooling is actually living up to the hype?

Enter GitHub Copilot CLI, a game-changer that’s fundamentally changing how I approach building applications on Azure. This isn’t just autocomplete on steroids. It’s a genuine productivity multiplier that’s helping teams ship features at a pace we couldn’t have imagined just a year ago, maybe even a few months ago.

What Makes Copilot CLI Different

You’re probably familiar with GitHub Copilot in your IDE, suggesting code as you type. Copilot CLI takes a different approach. It lives in your terminal, where you spend a huge chunk of your day running commands, deploying code, and managing infrastructure.

The beauty of Copilot CLI is its understanding of context. It knows you’re working in Azure. It understands your project structure. It can suggest complete command sequences that would normally require you to dig through documentation.

Real-World Impact on Development Speed

Let me give you a concrete example. Last week, I needed to set up a new Azure Function with blob storage triggers, configure monitoring, and deploy it to a staging environment. Traditionally, this would involve:

• Looking up the Azure CLI syntax for creating function apps
• Remembering the right flags for runtime and region
• Setting up storage account connections
• Configuring Application Insights
• Writing deployment scripts
• Testing everything locally first

With Copilot CLI, I described what I needed in plain English. It generated the exact command sequence, including error handling and best practices I might have overlooked. What would have taken an hour or two took maybe 15 minutes.

Natural Language to Complex Commands

The real power comes from turning intent into action. Instead of memorizing complex Azure CLI syntax, you can ask questions like:

“Create a container app with autoscaling and connect it to my existing PostgreSQL database”

“Deploy this app to three regions with traffic manager for load balancing”

“Set up monitoring alerts for when my function execution time exceeds 5 seconds”

Copilot CLI translates these requests into proper Azure CLI commands, complete with the right parameters and flags. It’s like having a senior Azure architect sitting next to you.

Faster Iteration Cycles

Where this really shines is during rapid prototyping and feature development. When you’re exploring a new Azure service or trying to implement a feature quickly, the feedback loop is everything.

Instead of context-switching between your editor, browser, and documentation, you stay in the flow. Need to check your current resource groups? Ask. Want to deploy a quick test? Describe it. Need to roll back a change? Just say so.

This compressed feedback loop means you can iterate on features multiple times in the span it would have previously taken to do it once.

Beyond Simple Commands

Copilot CLI isn’t just about generating single commands. It helps with entire workflows. Setting up CI/CD pipelines, configuring networking rules, managing secrets and certificates – these multi-step processes become conversations rather than chores.

I’ve seen team members who were less familiar with Azure infrastructure become significantly more productive. The learning curve flattens because they’re learning by doing, with AI assistance that explains what each command does and why.

Integration with Your Development Workflow

What I appreciate most is how Copilot CLI fits into existing workflows without forcing you to change how you work. It enhances your terminal experience rather than replacing it. You can review suggested commands before running them, modify them as needed, and build up your own understanding over time.

For Azure-specific development, this means you can focus on solving business problems rather than fighting with infrastructure syntax. Your cognitive load drops dramatically when you’re not constantly switching between writing application code and remembering the exact flags for Azure CLI commands.

The Compound Effect

Here’s what I’ve noticed after a few days of using Copilot CLI daily: the time savings compound. Every command you don’t have to look up, every deployment script you don’t have to debug, every configuration you get right the first time – it all adds up.

Features that used to take a sprint now take days. Proof of concepts that took days now take hours. The velocity increase isn’t linear, it’s exponential.

Getting Started

If you’re building on Azure and haven’t tried Copilot CLI yet, I’d strongly encourage giving it a shot. The setup is straightforward, and the productivity gains start immediately. You don’t need to be an AI expert or change your entire workflow.

Start with simple commands and gradually build up to more complex operations. Let it suggest, review what it generates, and learn from the patterns. Before long, you’ll wonder how you ever managed without it.

The Future of Development

This feels like a glimpse into where software development is heading. We’re moving from memorizing syntax to expressing intent. From fighting tools to collaborating with them. From spending time on mechanical tasks to focusing on creative problem-solving.

For those of us building on Azure, Copilot CLI represents a significant step forward in how quickly we can move from idea to deployed feature. And in today’s competitive landscape, that speed matters more than ever.

The tools are here. The technology works. The only question is: how much faster could your team ship if you started using them today?

Ready to get started – https://github.com/features/copilot/cli

.

Microsoft Ignite 2025 reaffirmed that AI is now a first-class development model across the Azure platform, not just an optional add-on. Among the many announcements at Ignite, updates to Azure App Service (Web Apps) and the broader Azure AI ecosystem directly affect how developers build intelligent, cloud-native applications — including web apps augmented with AI capabilities, semantic search, and agentic workflows.

This article walks through:

• Key App Service / Web Apps announcements
• The AI platform enhancements that Web Apps can leverage
• Architectural patterns for integrating AI into web workloads
• Infrastructure automation with Terraform and secure deployment patterns

What’s New in Azure App Service at Ignite 2025

At Ignite 2025, the Azure App Service team announced a set of updates focused on modernization, developer productivity, and AI integration readiness:

1. Managed Instance on Azure App Service (Public Preview)

A major new capability — Managed Instance on Azure App Service — entered public preview. It is designed to simplify migration of legacy web applications (especially classic ASP.NET and .NET apps with Windows dependencies) to a managed PaaS runtime with minimal code changes.

Key benefits:

• Run legacy Windows web apps with Hyper-V nested virtualization.
• Use configuration and installation scripts for dependencies rather than rewriting code.
• Maintain automatic OS and .NET patching and updates.
• Direct RDP access to instances for troubleshooting in complex migration scenarios.

This matters for AI because modernization often precedes adding AI-driven features — a classic app first needs to run reliably on App Service before layering in services like semantic search, chat UI APIs, or automated content enrichment workflows.

2. Enhanced Runtime and Language Support

Alongside the Managed Instance preview, App Service continues to expand support for modern runtimes, frameworks, and developer experiences. While not AI-specific, these enhancements make it easier to host intelligent applications built with:

• .NET 8/9 and ASP.NET Core
• Node.js 20+
• Java 25 and beyond
• Containers on App Service (Linux) with improved tooling

These runtimes interoperate cleanly with Azure AI APIs and SDKs. For example, a Node.js web app can call Azure AI Search or an LLM API directly via SDK or REST.

Azure AI Platform Enhancements from Ignite 2025

Ignite 2025 made clear that the foundation for AI-driven web apps is not just the compute layer, but platform services that encapsulate semantic understanding, retrieval-augmented generation (RAG), and agentic workflows.

1. Microsoft Foundry — Unified AI Agent Platform

At Ignite, Azure AI Foundry was rebranded and enhanced as “Microsoft Foundry”, a unified platform for building, deploying, and governing enterprise-grade AI agents across workloads. Foundry now supports:

• Multi-agent orchestration
• Open standards for models (including Anthropic Claude and OpenAI models)
• Seamless integration with enterprise data and APIs

Foundry is not App Service, but it is the AI backbone you are likely to call from web apps for:

• Conversational AI interfaces
• Workflow automation (e.g., ticket triaging, contextual assistants)
• Long-running agentic tasks tied to user sessions or backend triggers

More on Foundry’s updates are in the Microsoft documentation. TECHCOMMUNITY.MICROSOFT.COM+1

2. Semantic Retrieval and AI Search

Azure AI Search (formerly Cognitive Search) continues to evolve with RAG-friendly patterns that integrate vector search, semantic ranking, and LLMs. This makes it much easier to add “chat with your data” experiences into web UIs.

Azure AI Search documentation is here:
🔗 https://learn.microsoft.com/azure/search/what-is-azure-ai-search

Typical patterns for Web Apps include:

• Document ingestion pipelines (Azure Blob, OneLake, Cosmos DB)
• Indexer + semantic search for natural language queries
• LLM integration to summarize and respond conversationally

Patterns for Integrating AI into Azure Web Apps

Below are architectural patterns you might adopt when extending web apps with AI capabilities following Ignite 2025.

Pattern 1 — RAG-Driven Conversational UI

1. Web App Frontend on App Service (e.g., React, Blazor).
2. API Layer in Azure Functions or .NET backend to handle requests.
3. Azure AI Search + vector store for semantic retrieval.
4. OpenAI or Foundry Models for response generation.

Flow:

1. User asks a question in web UI.
2. Backend calls Azure AI Search to retrieve relevant documents.
3. Retrieved context is sent to a generative model.
4. Model output is returned to the UI.

var client = new Azure.AI.OpenAI.OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
var response = await client.GetCompletionsAsync(
    deploymentOrModelName: "gpt-4.1-enterprise",
    new Azure.AI.OpenAI.CompletionsOptions
    {
        Prompts = { "Summarize these docs for a tech user: ..." }
    });

Pattern 2 — Agentic Backend Workflows

If your web app needs to trigger longer-running workflows (e.g., order fulfillment automation, customer support routing), you can:

1. Expose an HTTP trigger from your Web App or Azure Function.
2. Hand off processing to a Foundry agent (via API) that orchestrates multi-step logic.
3. Use Queues (Service Bus, Storage Queues) for reliable message passing.

This pattern decouples UI from backend processing, letting agents execute tasks with traceability and governance — critical for compliance.

Infrastructure as Code — Terraform & Bicep

Automation and repeatability are essential. Below is a sample Terraform snippet to provision an App Service with a Managed Identity (for secure calls to Azure AI).

Notes:

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "rg" {
  name     = "rg-webapp-ai"
  location = "WestEurope"
}

resource "azurerm_app_service_plan" "plan" {
  name                = "asp-webai"
  resource_group_name = azurerm_resource_group.rg.name
  sku {
    tier = "PremiumV4"
    size = "P1v4"
  }
}

resource "azurerm_app_service" "webapp" {
  name                = "webapp-ai"
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  app_service_plan_id = azurerm_app_service_plan.plan.id

  identity {
    type = "SystemAssigned"
  }

  site_config {
    dotnet_framework_version = "v6.0"
  }

  app_settings = {
    "WEBSITE_RUN_FROM_PACKAGE" = "1"
    "AZURE_OPENAI_ENDPOINT"     = var.openai_endpoint
    "AZURE_OPENAI_MODEL"        = var.openai_model
  }
}

1. Use managed identities to authenticate to Azure AI services instead of static keys.
2. You can extend this snippet with Private Endpoints, Key Vault references, and app settings for AI service integration.

Terraform vs Bicep vs ARM:

• Terraform excels with multi-cloud teams and state management.
• Bicep/ARM provide first-class Azure tooling and tighter integration with Azure RBAC.
• Choose based on team skills and governance requirements.

Security, Governance, and Identity

Ignite announcements highlighted enterprise-grade security for AI agents and services, including identity integration and access policies. For Web Apps calling AI APIs:

• Use Managed Identity and Azure RBAC instead of connection strings.
• Store secrets (if needed) in Azure Key Vault with MSI access.
• Secure backend APIs with Azure AD tokens.

Summary

Ignite 2025 reinforced that AI is deeply woven into the future of Azure compute and application platforms:

• Azure App Service continues to modernize with managed instances, enhanced runtimes, and improved migration tooling.
• The Azure AI ecosystem — especially Microsoft Foundry and Azure AI Search — enables developers to add semantic, conversational, and agentic capabilities to web apps.
• Architectural patterns (RAG, agent workflows) and secure automation (Terraform, managed identity) help deliver production-grade intelligent applications.

As you plan your next wave of web apps, consider AI as a core design axis, not an afterthought.

Further Reading

• Azure App Service documentation — https://learn.microsoft.com/azure/app-service/
• Azure AI services overview — https://learn.microsoft.com/azure/ai-services/what-are-ai-services
• Azure AI Search documentation — https://learn.microsoft.com/azure/search/what-is-azure-ai-search
• Microsoft Foundry docs — https://learn.microsoft.com/azure/ai-foundry/overview

This is my entry for this year’s Azure Back To School. Massive shout-out to Dwayne Natwick for organising this every year!

If you’re building on Azure, integrating GitHub Copilot into your workflow can save time, reduce friction, and help with infrastructure, deployment, and debugging, not just writing business logic.

Below is an explanation of how to use it, what works well, and what to be aware of.

What “Copilot + Azure” means today

Here’s how the two worlds overlap currently:

GitHub Copilot for Azure: a VS Code extension that lets you ask about Azure, manage resources, deploy, and diagnose, all from the Copilot chat interface.

Copilot + Azure DevOps / Azure Repos: You can use Copilot with Azure Repos for suggestions, commit messages, and PR descriptions.

Agentic DevOps vision: Copilot is evolving into autonomous “agents” that can perform multi-step tasks, such as refactoring, testing, and fixing bugs. Azure pipelines, boards, and resource operations may tie into that.

Inner sourcing/knowledge reuse via MCP server: You can integrate Azure DevOps/Azure MCP server with Copilot, allowing it to suggest content from your organisation’s own modules or documentation.

Azure Boards integration: you can assign work items from Azure Boards to a Copilot coding agent, and track progress.

So it’s not just “autocomplete in VS Code + Azure SDK”, Copilot is pushing into infrastructure, operations, and agentic automation.

How to get started (practical steps)

• Install Copilot and the Azure extension
  • In VS Code, get the GitHub Copilot for Azure extension.
  • You need a Copilot license (Pro, Business, etc.)
• Use @azure prompts in Copilot Chat
  • Once the extension is active, you can prefix prompts with @azure to query Azure resource info, diagnose, or even do operations.

Examples:

@azure Deploy an Azure Function HTTP trigger with .NET 8
@azure What are the cost tiers for Azure SQL in West Europe?
@azure Diagnose why my webapp is showing 500 errors

• Deploy from within the editor
  • Copilot for Azure can suggest CLI commands, resource templates, or deployment steps without you switching to the Azure Portal.
• Use Copilot in code + infra files
  • When you edit ARM templates, Bicep, Terraform alongside app code, Copilot can help complete resource definitions, parameter scaffolding, and provide relevant snippets.
• Explore agentic features
  • Try Copilot agents for multi-file changes, code refactors, or cloud migration tasks. (Feature availability depends on your subscription and preview access.)
• Enable MCP / context servers
  • For tighter integration (e.g. your organization’s code modules, Azure DevOps context), you can configure MCP (Model Context Protocol) servers so Copilot has richer context

Benefits you’ll see

• Faster iteration: fewer trips to Azure portal or docs.
• Context-aware suggestions: Copilot knows your Azure setup or resource naming.
• Multi-step automation: not just code, but “deploy, test, monitor” flows.
• Consistency: reuse corporate standards or templates via inner sourcing.
• Better dev-ops synergy: bridging code and cloud operations in one interface.

Example scenario
Let’s say you’re building a serverless API on Azure Functions + Cosmos DB.

@azure Create an Azure Function project with HTTP trigger, .NET 8

Copilot responds with scaffold commands, project template.

@azure Provision a Cosmos DB instance with RU/s 400, region North Europe

Next up try

@azure Deploy this function and connect to Cosmos DB

It issues az commands or points you to CI/CD YAML.

If you see any errors after deployment:

@azure Diagnose 500 error in function logs

It helps inspect logs, points you to misconfigurations or missing settings.

Meanwhile, inside code files, Copilot suggests resource names, configuration keys, and helper snippets.

Future direction & what to watch

• More tasks handed over to the coding agent (not just suggestions).
• Better integration into Azure services (monitoring, cost, policies).
• Richer context via MCP so that Copilot is aware of your entire org’s patterns.
• Tighter link between Azure Boards / Pipelines and Copilot agents. (You already can assign work items to Copilot.
• Stronger guardrails: security analysis baked into generated infra code.

Summary

I use this GitHub Copilot on a daily basis and I recommend you at least take a look at it, if not use it daily too!

This years Microsoft Build was full of new releases, new services, new ways of doing things, and yep, lots of AI. The following are just some of the areas that grabbed my interest whilst attending the conference, due to working at it, I havent had time to try the demos, check out some of the announcements and get hands on with the tech that has newly been released, but I will in the coming weeks.

If like me you havent managed to catchup on the announcements then you can read the book of news for Build 2025.

If you are looking to upgrade your existing .net Framework application to .net Core then checkout thiese links:-

Docs: https://learn.microsoft.com/en-us/dotnet/core/porting/upgrade-assistant-overview
Upgrade Extension: https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.upgradeassistant

If you would like co-pilot to help you upgrade your version of a .net Core application then here are some very useful links.

• Upgrading a .NET 6 repo to .NET 9 with GitHub Copilot – Upgrading a .NET 6 repo to .NET 9 with GitHub Copilot
• https://devblogs.microsoft.com/dotnet/github-copilot-upgrade-dotnet/ – Accelerate Your .NET Upgrades with GitHub Copilot
• https://learn.microsoft.com/en-us/dotnet/core/porting/github-copilot-app-modernization-overview – What is GitHub Copilot app modernization – upgrade for .NET?
• http://aka.ms/ghcp-appmod/dotnet-upgrade-vsix – GitHub Copilot app modernization – upgrade for .NET
• https://learn.microsoft.com/en-us/dotnet/core/porting/github-copilot-app-modernization-faq – GitHub Copilot app modernization – upgrade for .NET FAQ
• https://dotnet.microsoft.com/en-us/platform/upgrade – Agent mode in Visual Studio makes .NET upgrades easier than ever

There is also some help available if you are just starting out and would like help deploying your application to Azure – Quickstart: Deploy your application to Azure with agent mode in GitHub Copilot for Azure

If you are interested in Hosting remote MCP Server’s in Azure App Service then this articlae has you covered – https://techcommunity.microsoft.com/blog/appsonazureblog/host-remote-mcp-servers-in-azure-app-service/4405082

Two of my favourite annoucements recently were the GitHub CoPilot Coding Agent and the new SRE Agent coming soon (you can sign up for this preview now!) and read more about the SRE agent – https://techcommunity.microsoft.com/blog/azurepaasblog/introducing-azure-sre-agent/4414569

Interested in some AI Labs then look no further than – https://ai.azure.com/labs

Maybe you like creating videos and now within Azure you can create high-quality visual content with GPT-Image-1 and Sora on Azure OpenAI—tailored for professional use cases – https://github.com/Azure-Samples/visionary-lab