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

Introduction

This blog post is part of this years Azure Spring Clean an event which is ran to promote well managed Azure tenants. To achieve this, they have community driven articles that highlight best-practice, lessons learned, and help with some of the more difficult topics of Azure Management.

Azure Policy is a powerful governance tool that helps organizations enforce compliance across their Azure environments. By automating the deployment of Azure Policies using Bicep and the Azure Verified Modules (AVM) GitHub repository, you can ensure consistent policy enforcement while leveraging modular, reusable infrastructure as code.

This guide assumes you already have your environment set up in VS Code, including Bicep tooling and Azure CLI authentication.

Prerequisites

Before deploying Azure Policies with Bicep, ensure you have:

• VS Code with the Bicep extension installed.
• Azure CLI installed and authenticated (az login).
• Bicep CLI installed (az bicep install if needed).
• Git installed and cloned the Azure Verified Modules (AVM) repository.
• Appropriate permissions to create and assign policies in Azure.

Deploying Policies to Management Groups and Subscriptions

Deploying policies at the management group level is a best practice for organizations that manage multiple subscriptions under a common governance framework. By applying policies at this higher level, you can ensure:

• Consistency: Enforce compliance standards across all subscriptions within the management group without the need for redundant deployments.
• Efficiency: Reduce operational overhead by managing policies centrally instead of applying them individually to each subscription.
• Scalability: As new subscriptions are added to the management group, they automatically inherit the assigned policies, ensuring continuous compliance.

To apply policies at different scopes, use the following commands:

Deploying to a Management Group

$location = ‘West Europe’
$management-group-id = ‘mg-demo’

az deployment mg create \
  --management-group-id $management-group-id \
  --location $location \
  --template-file main.bicep \
  --parameters @parameters.json \
  --name MGPolicyDeployment

Deploying to a Subscription

az deployment sub create \
  --location eastus \
  --template-file main.bicep \
  --parameters @parameters.json \
  --name SUBPolicyDeployment

You can also check in the Azure Portal under Policy -> Assignments

Lets take a look at some example Azure Policies you may want to add to your management groups. In this example I would add them to a file called deployPolicyMg.bicep

targetScope = 'managementGroup'

@description('Policy Assignment Management Group - Allowed Locations')
module assignAllowedLocationPolicy 'policyAssignmentMg.bicep' = if (deployAllowedLocations) {
  name: 'AllowedLocations'
  params: {
    name: 'Allowed Locations'
    displayName: 'Allowed Locations'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/e56962a6-4747-49cd-b67b-bf8b01975c4c'
    location: primaryLocation
    identity: 'None'
    parameters:{
      listOfAllowedLocations: {
        value: allowedLocations
    }
  }
}
}

@description('Policy Assignment Management Group - ISO 27001-2013')
module assignIso27001Policy 'policyAssignmentMg.bicep' = if (deployIso27001Policy) {
  name: 'Iso27001'
  params: {
    name: 'ISO 27001-2013'
    displayName: 'ISO 27001-2013'
    policyDefinitionId: '/providers/Microsoft.Authorization/policySetDefinitions/89c6cddc-1c73-4ac1-b19c-54d1a15a42f2'
    location: primaryLocation
    identity: 'SystemAssigned'
    roleDefinitionIds: []
  }
}

@description('Policy Assignment Management Group - Azure Security Benchmark')
module assignAscPolicy 'policyAssignmentMg.bicep' = if (deployAzureSecurityBenchmark) {
  name: 'AzureSecurityBenchmark'
  params: {
    name: 'Azure Security Benchmark'
    displayName: 'Azure Security Benchmark'
    policyDefinitionId: '/providers/Microsoft.Authorization/policySetDefinitions/1f3afdf9-d0c9-4c3d-847f-89da613e70a8'
    location: primaryLocation
    identity: 'None'
    roleDefinitionIds: []
  }
}

The above code example makes use of some variables which I add to a .bicepparameters file which would look like this:-

using './deployPolicyMg.bicep'

param deployAllowedLocations = true
param deployIso27001Policy = true
param deployAzureSecurityBenchmark = true


Lets take a look at some example Azure Policies you may want to add to a subscription. In this example I would add them to  a file called deployPolicySub.bicep

targetScope = 'subscription'

@description('Assign Policies to Subscription - Require an Owner tag on resource groups')
module assignReguireRgOwnerTagPolicy 'policyAssignmentSub.bicep' =  if (tagAtSubscriptionLevel && ownerTagResourceGroupsPolicy) {
  name: 'reguireRgOwnerTagPolicy'
  params: {
    name: 'Require an Owner tag on resource groups'
    displayName: 'Require an Owner tag on resource groups'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/96670d01-0a4d-4649-9c89-2d3abc0a5025'
    location: primaryLocation
    identity: 'None'
    parameters:{
      tagName: {
        value: ownerTagName
    }
  }
}
}

@description('Assign Policies to Subscription - Require a DeployedBy tag on resource groups')
module assignReguireRgDeployedByTagPolicy 'policyAssignmentSub.bicep' =  if (tagAtSubscriptionLevel && deployedByTagResourceGroupsPolicy) {
  name: 'reguireRgDeployedByTagPolicy'
  params: {
    name: 'Require a DeployedBy tag on resource groups'
    displayName: 'Require a DeployedBy tag on resource groups'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/96670d01-0a4d-4649-9c89-2d3abc0a5025'
    location: primaryLocation
    identity: 'None'
    parameters:{
      tagName: {
        value: deployByTagName
    }
  }
}
}

The code above is an example of how you could add Azure Policies into a subscription.

The above code example makes use of some variables which I add to a .bicepparameters file which would look like this:-

using './deployPolicySub.bicep'

param tagAtSubscriptionLevel = true
param ownerTagResourceGroupsPolicy = true
param deployedByTagResourceGroupsPolicy = true

Conclusion

By leveraging Azure Bicep and Azure Verified Modules, you can automate and standardize Azure Policy deployment efficiently. Start using AVM today to maintain governance and compliance effortlessly!

This year’s Festive Tech Calendar videos are available on YouTube with the link to the playlist.

A huge THANK YOU to everyone who took part, has watched the videos and learned and especially those who also donated to this years charity – thanks from all of us at the Festive Tech Calendar team!

Day 1

• Day 1 – Yippee-ki-yay! Let’s Build a Die Hard Quiz Power App using Copilot – YouTube
• Day 1 – Keynote☃️ Whispers of Winter: A Festive Poem ✨ – YouTube
• Day 1 – Christmas planning in Loop: A festive collaboration adventure! 🎅 – YouTube

Day 2

• Day 2 – Merry Scripting: Automate Festive Windows Wallpapers with PowerShell – YouTube

Day 3

• Day 3 – Deploying AVD base infrastructure using DevOps pipelines – YouTube
• Day 3 – Immersive Tour of Christmas Traditions Around the World – YouTube

Day 4

• Day 4 – Building Personalised Cloud Year in Review Videos – YouTube
• Day 4 – AKS cluster mesh in VWAN environment – YouTube
• Day 4 – No IDE Required: How CLI Tools Unleashed .NET’s Flexibility – YouTube

Day 5

• Day 5 – Magic or Ai – YouTube

Day 6

• Day 6 – Festive fun with Microsoft Designer – YouTube

Day 7

• Day 7 – How to Ace those Azure Exams! – YouTube
• Day 7 – How to Improve Your Azure Kubernetes Security Posture with Threat Model – YouTube

Day 8

• Day 8 – Jingle Bells and AI Spells: Exploring Semantic Kernel with Azure OpenAI – YouTube

Day 9

• Day 9 – Let’s create a festive greeting card together – YouTube
• Day 9 – Microsoft Defender Vulnerability Management – YouTube

Day 10

• Day 10 – Microsoft 365 Copilot: 8 Ways to Simplify Your Tasks – YouTube
• Day 10 – Building a Reliable Deployment Pipeline: Don’t Let Tests Break Your Pipeline – YouTube

Day 11

• Day 11 – Optimising Customer Experience with Dynamics 365 Contact Center: A Festive Approach – YouTube

Day 13

• Day 13 – Securing MS Fabric in the traditional way – YouTube

Day 14

• Day 14 – Personalized Event Discovery – YouTube

Day 15

• Day 15 – So, you think you can agent? – YouTube

Day 16

• Day 16 – Ho-Ho-Hold onto Your Hats! Real-Time Data Magic from Santa’s Sleigh – YouTube
• Day 16 – Transforming Non-Profit with Power Platform – YouTube

Day 17

• Day 17 – How to Make My Christmas Snowier with GitHub Copilot Workspaces – YouTube
• Day 17 – Ho Ho Whoa! 10 Tips for Data Warehousing in the Cloud – YouTube

Day 18

• Day 18 – Agentic Azure AI: Dungeons and Dragons at Christmas – YouTube
• Day 18 – Securing Tomorrow: Cybersecurity Visions for 2025 and Beyond – YouTube

Day 19

• Day 19 – Yule Log-in Safely: Entra ID Security overview – YouTube

Day 20

• Day 20 – Copilot Studio: Create a Hotel Reservation Assistant – YouTube
• Day 20 – The power of multimodal models – YouTube

Day 21

• Day 21 – AI-POWERED QUANTUM COMPUTING: THE NEW FRONTIER IN PROBLEM-SOLVING – YouTube
• Day 21 – Santa’s Workshop: Magic with AKS and Bicep! – YouTube
• Day 21 – How to create an AI Web App with Azure AI Search Vector Embeddings and Fabric Pipelines – YouTube

Day 22

• Day 22 – AI Santa’s Workshop: Custom Rhymes and Cards – YouTube
• Day 22 – The Influence of Generative AI in Festival Season Predictions for the Retail Industry – YouTube
• Day 22 – Improve Kubernetes with k8sGPT – YouTube
• Day 22 – Harnessing Simulation and Evaluation in Azure AI Studio – YouTube

Day 23

• Day 23 – Santa’s Festive Guide to Entra ID Security Defaults! – YouTube
• Day 23 – GitHub Copilot Tutorial Automate Coding, Azure, & Infrastructure in Minutes! – YouTube
• Day 23 – Building a Cyber Risk Management Action Plan to protect Santa Claus vulnerabilities – YouTube

Day 25

• Day 25 – 2024 in Cloud Native – A Festive Retrospective – YouTube
• Day 25 – The Essentials of Azure Storage: Key Concepts and Best Practices – YouTube
• Day 25 – Getting your hands dirty with SharePoint’s Brand new Centre – YouTube

Day 26

• Day 26 – #MVPWrapped, #CommunityWrapped and/or #MCTWrapped – YouTube
• Day 26 – Developing Custom Copilots with Azure AI Studio, PromptFlow and .NET – YouTube
• Day 26 – Using Purview eDiscovery to retrieve Teams chats for Incident Response! – YouTube
• Day 26 – Language Detection in Modern Applications with Azure AI – YouTube

Day 27

• Day 27 – The ABC’s of Christmas Continuity – YouTube
• Day 27 – Top 10 Ways to Save Money and Manage Cloud Costs on Microsoft Azure – YouTube
• Day 27 – Extending the PAW mentality to the cloud – YouTube

Day 28

• Day 28 – New Year, New Savings: Mastering Azure NetApp Files Cost Optimisation – YouTube

Day 29

• Day 29 – Diagram As Code – YouTube
• Day 29 – Microsoft Copilot Studio and Power platform – YouTube
• Day 29 – Want to set up your own tech meetup? Start here! – YouTube

Day 30

• Day 30 – Cowrie Honeypot Integration with Microsoft Sentinel – YouTube
• Day 30 – Aspiring .NET with Azure Open AI – YouTube

Day 31

• Day 31 – AI in Every City: embrace the magic of the holidays with Copilot!
• Day 31 – Securing Cloud Applications: Best Practices for Azure Developers and Architects
• Day 31 – Build a warp speed time-to-market API with DAB and Azure Container Apps.
• Day 31 – Query Store Advancements Recording

This year’s Festive Tech Calendar videos are available on YouTube with the link to the playlist.