24 Days of .NET and Azure Integration: A Technical Advent Calendar

December is traditionally a time for Advent calendars, but this year I’m doing something a little different.

Throughout December, I’ll be publishing 24 technical articles covering .NET development, Azure Integration PaaS, API management and the evolving world of AI integration.

The aim is simple: 24 days of practical engineering content, exploring technologies, architectural patterns and implementation approaches that solve real-world problems.

Welcome to 24 Days of .NET and Azure.

Why this series?

The technology landscape is evolving quickly. .NET continues to mature, organisations are investing in API-led architectures, and AI agents are introducing new requirements for how applications, services and business capabilities are exposed and consumed.

For architects and developers, this creates some interesting challenges.

How do we build resilient, maintainable .NET applications? How should we connect distributed systems? How do we govern APIs across an enterprise? And, increasingly, how do we make existing business capabilities available to AI agents without compromising security, governance or control?

These are the questions I want to explore throughout December.

This isn’t intended to be another series of introductory tutorials or summaries of product documentation. Each article will focus on a practical technical subject, with implementation examples, architecture diagrams, code and considerations for taking solutions into production.

The emphasis will be on understanding not just how something works, but why you might choose one approach over another.

The 24-day journey

I’ve organised the series into four themes, each building on the previous one.

Week 1: Modern .NET engineering

We’ll start with the foundations of modern application development, looking at the tools and architectural approaches that help build production-ready applications.

1. What’s New in .NET 10: What Actually Matters to Developers

2. Feature-Based Architecture in .NET: Organising Applications Around Capabilities

3. Building Production-Ready APIs with ASP.NET Core

4. Resilience in .NET: Retries, Circuit Breakers and Timeouts

5. Observability in .NET: Making Distributed Applications Understandable

6. Securing .NET APIs with Microsoft Entra ID

Week 2: Azure Integration PaaS

With the application foundations established, we’ll move into distributed systems and enterprise integration.

1. Azure Functions: Choosing the Right Hosting and Execution Model

2. Azure Service Bus: Designing Reliable Messaging Between Systems

3. Event Grid vs Service Bus: Understanding the Difference

4. Azure Logic Apps: When to Use Low-Code Integration in an Engineering Platform

5. Hybrid Integration: Connecting Azure to On-Premises Systems

6. Choosing the Right Azure Integration Service: A Practical Architecture Guide

Week 3: API management and governance

APIs are increasingly central to how organisations connect systems, expose capabilities and enable innovation. This week explores the platforms and practices needed to manage them effectively.

1. Azure API Management: More Than Just an API Gateway

2. Azure API Management Policies: Building Security and Governance into Your APIs

3. Azure API Center: Building an Enterprise API Inventory

4. API Lifecycle Management: From Design to Retirement

5. Deploying Azure API Management with Infrastructure as Code

6. Building an API Developer Experience with Azure API Center

Week 4: AI, MCP and the future of integration

We’ll finish by looking at one of the most interesting developments in application and integration architecture: making enterprise capabilities accessible to AI agents.

1. Understanding MCP: Why APIs Alone Aren’t Enough for AI Agents

2. Turning Existing REST APIs into MCP Tools with Azure API Management

3. Azure API Center: Creating an Enterprise MCP Server Registry

4. Securing MCP Servers: Authentication, Authorisation and Governance

5. Managing AI Agent Consumption: Observability, Rate Limits and Cost Control

6. Building an Enterprise-Ready AI Integration Platform with Azure

Practical engineering, not just theory

A key principle throughout the series is that the content needs to be useful beyond the article itself.

Where appropriate, I’ll include:

• Working code examples – primarily using modern C# and .NET 10.
• Architecture diagrams – showing how services and components interact.
• Infrastructure as Code – using technologies such as Bicep where relevant.
• Security considerations – authentication, authorisation and appropriate access controls.
• Operational considerations – resilience, observability, performance and cost.
• Architectural trade-offs – understanding when a particular approach makes sense and when it doesn’t.

I’ll also distinguish between documented product capabilities, implementation examples and architectural recommendations. Technology moves quickly, particularly in the AI space, so accuracy matters.

A particular focus on APIs and AI readiness

One area I’m particularly interested in is the relationship between API management and AI.

The introduction of the Model Context Protocol (MCP) creates another way for AI applications and agents to interact with external systems and business capabilities.

However, making APIs and services available to AI agents introduces questions that go beyond simply exposing an endpoint.

How do we control access? How do we discover available capabilities? How do we manage consumption? How do we monitor activity? And how do we maintain appropriate enterprise governance?

Technologies such as Azure API Management and Azure API Center have important roles to play in this conversation.

I want to explore these subjects in detail, looking at how existing API investments can support an AI-enabled architecture without losing the security, control and governance that enterprise platforms require.

Follow along

The first article will be published on 1 December, with a new post every day through to Christmas Eve.

I’ll share each article here on the blog and through LinkedIn.

Whether you’re a .NET developer, cloud architect, integration specialist or technology leader, I hope you’ll find something useful in the series.

If there’s a particular subject you’d like me to explore, feel free to get in touch. I’m always interested in hearing about the challenges people are tackling in their own environments.

24 days. 24 articles. A lot of engineering.

Let’s get started.