Browse All Blogs (68)

Thomas Maurer introduces the new digital sovereignty adoption guidance in the Microsoft Cloud Adoption Framework, explaining the sovereign cloud continuum and a practical three-phase path (planning, architecture/governance, and operations) for building and running controlled Azure workloads across public, private, and partner cloud models.

Matt Stratton talks with Naga Sujitha Vummaneni and Sundeep Bobba about reframing CI/CD pipelines as control systems, using feedback signals, constraints, and bounded automation to keep delivery stable—especially as AI-driven changes increase the pace and volume of deployments.

Thomas Maurer shares takeaways from a discussion at the HPE Customer Innovation Center on Azure Local and Microsoft’s Sovereign Private Cloud vision, focusing on how organizations can meet data residency, compliance, and operational control requirements while still using Azure-consistent capabilities in hybrid and edge environments.

John Edward explains Microsoft Edge’s plan to retire Manifest V2 extensions for enterprises starting in early 2027, what the rollout timeline looks like, and what it means for extension developers and IT admins managing allow-lists and force-installed extensions.

Topi Nuotos explains why his team replaced a shared Excel tracker with a Microsoft Fabric App, and how Fabric Apps adds an application layer on top of Fabric for building data-driven web apps with preconfigured infrastructure.

Jesse Houwing shares a practical checklist for deciding whether a third-party GitHub Action is safe to run in your CI environment, focusing on maintenance signals, dependency hygiene, release integrity, and governance. He also explains why pinning what you run matters, and compares SHA pinning, immutable releases, and action lock files.

Jesse Houwing explains why GitHub Copilot cloud agent sessions can’t be spawned from GitHub Actions using GITHUB_TOKEN, and how GitHub’s accountability model (identity, billing, and auditability) shapes what “agentic workflows” can do today. He then lays out practical orchestration patterns that work, with concrete YAML examples.

Jesse Houwing explains how to stop GitHub Copilot agents from confidently inventing details about fast-moving tools by grounding them in a local clone of the real repository, then forcing answers to be backed by file-and-line citations from the source.

John Edward covers a Copilot Studio authentication update that adds Microsoft Entra ID-based identity for both delegated user access and service-to-service (S2S) scenarios, aimed at making enterprise agent deployments easier to secure and integrate with existing applications.

John Edward summarizes Microsoft’s warning that firewall, proxy, and TLS inspection setups can break Windows Update connectivity, leaving devices without security patches. The post explains the certificate trust model behind Windows Update, why wildcard FQDN allowlists matter, and how admins can use PowerShell and audit logs to confirm the issue before changing network rules.

Andrew Lock digs into .NET 11 preview 7’s new union types and closed class hierarchies, focusing on where System.Text.Json serialization and deserialization fall over. He shows the default behavior, the exceptions you’ll hit with inferred polymorphism, and the workarounds using JsonDerivedType and custom union type classifiers.

John Edward lays out a practical checklist for taking an AI agent from demo to production using Microsoft Copilot and Azure AI Foundry, focusing on architecture choices, grounding with enterprise data, controlled tool permissions, evaluation, monitoring, and cost/latency controls.

DevClass reviews Kubernetes v1.37 (Garhwal), focusing on production-readiness changes like the Metrics API reaching GA, upcoming removals of kube-dns, IPVS mode in kube-proxy, and cgroup v1, plus new features around autoscaling, watch cache behavior, and stricter YAML conventions via KYAML.

Scott Hanselman walks through diagnosing unexpectedly slow 10GbE file transfers by isolating storage from networking with iperf3, then fixing a Windows NIC bottleneck by increasing receive buffers and disabling Large Send Offload (LSO) V2 for IPv4 on an Intel E610-XT2 adapter.

John Naguib lays out a practical architecture for building self-improving AI agents on Azure, focusing on controlled feedback loops (evaluate, learn, test, approve) rather than uncontrolled self-modification. The guide covers agent runtime, tool calling, RAG, memory/experience stores, evaluation, observability, and governance for production use.

John Naguib explains a Copilot Studio billing change taking effect on September 1, 2026: existing agents and workflows built with the GitHub Copilot harness will start consuming Copilot Credits. The post breaks down what’s affected, how credit consumption works (authoring vs runtime), and what admins can review in PPAC to avoid cost surprises.

Andrew Lock shows how to get the total logical CPU count on a host machine (not just the CPUs available to the current process) in modern .NET. The post compares `Environment.ProcessorCount` behavior across runtimes and provides a cross-platform helper using P/Invoke on Windows/macOS and file parsing on Linux.

DevClass summarizes how Cursor designed its Origin Git repository service to handle Git at large scale, drawing on Vicent Martí’s write-up about Git’s DAG traversal costs, replica synchronization limits, and an object-storage-backed approach using a write-ahead log plus local NVMe caches.

Scott Hanselman walks through a real-world NAS migration from Synology to a UniFi UNAS Pro 8 using Windows and Robocopy, including how he debugged Windows error 665, handled NTFS Alternate Data Streams, and tuned Robocopy switches to avoid major performance traps.

Hidde de Smet explains Agent Plugins 1.0, a small packaging standard that lets teams ship portable Agent Skills and MCP server definitions once, while keeping Copilot-specific extras in a namespaced folder. The post covers the required file layout, manifest and MCP schemas, and enterprise governance controls for plugin and MCP server policy.

Matt Stratton talks with Doug Pagnutti about “industrial DevOps”: the long-running friction between corporate IT and plant-floor OT in manufacturing, why incentives and ticket-driven workflows create risky workarounds, and how security and data-sharing requirements are forcing the two worlds to converge.

John Edward explains Microsoft’s required Microsoft Defender for Endpoint update on Android ahead of infrastructure changes, including the minimum supported app version and the rollout timeline. The post focuses on what IT admins should do to avoid disruptions to mobile threat protection across managed and user-updated devices.

DevClass reports on ChainDrop, a new Shai-Hulud npm worm variant that compromises packages via tarballs and can persist through repository configuration files, enabling credential theft and further propagation. The article explains how the attack spreads through npm, GitHub, and developer tools like VS Code, and outlines practical checks and mitigations.

John Edward breaks down Microsoft’s August 2026 Windows security update, focusing on the phased Secure Boot certificate rollout, servicing stack improvements, and what admins and users should expect during installation (including a possible extra restart) across Windows 11, Windows 10, and Windows Server.

John Edward explains how to apply FinOps practices to high-volume Azure AI workloads, focusing on the real cost drivers behind model usage, compute, and request patterns. The article lays out practical tactics—visibility, right-sizing, scaling, batching, caching, and guardrails—to keep AI spend predictable without sacrificing latency or reliability.

DevClass reports on the Agent Plugins 1.0 specification, a cross-vendor effort to package agent skills and tool connectivity in a portable, file-system-based format. The goal is to make agent capabilities modular and reusable across compatible clients like VS Code and GitHub Copilot.

John Edward covers a Microsoft Defender update that surfaces AI-generated Microsoft Purview Insider Risk Management triage summaries directly in the Defender alert queue, helping SOC analysts and insider risk investigators triage alerts faster while keeping the full investigation workflow in Purview.

Andrew Lock explains the new CSRF protection in ASP.NET Core (.NET 11 preview 6) that uses Fetch Metadata HTTP headers instead of synchronizer tokens, including how the middleware decides to allow or deny requests and what changes (if any) app authors need to make.

John Edward explains Microsoft’s retirement of support for the Microsoft Entra SSO plug-ins used with self-hosted Atlassian Jira and Confluence (Server/Data Center), what “unsupported” means in practice, and the security and operational risks organizations should plan for after July 31, 2026.

John Edward breaks down what GitHub Copilot does (and doesn’t) send to the service, how training and retention settings vary by subscription, and the practical security risks teams should plan for when using AI-assisted coding in real projects.

Andrew Lock explains the browser Fetch Metadata request headers (Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-Dest, and Sec-Fetch-User), what their values mean, and how servers can use them to spot suspicious cross-origin requests and add another layer of CSRF defense alongside tokens and SameSite cookies.

John Edward explains how to build an AI-powered IT support agent on Azure, using Azure AI Foundry with Azure OpenAI Service and (optionally) Azure AI Search for RAG-based answers grounded in internal documentation, plus ideas for automating common help desk actions like ticket creation and password resets.

John Edward outlines practical Azure architecture best practices for enterprise applications, covering the Azure Well-Architected Framework, scalability and high availability patterns, security with Zero Trust, observability, infrastructure as code, CI/CD, cost controls, networking, disaster recovery, and governance.

Hidde de Smet audits a local SKILL.md “skills” library spread across Claude Code, a shared .agents catalog, and GitHub Copilot’s VS Code setup, showing how silent failures (missing files, duplicates, stale references) accumulate over time and how to stocktake them with a checklist and a couple of shell one-liners.

John Edward explains why AI agents that look great in demos often break down in production, and what teams need to engineer around the model to make agents reliable at scale.

Thomas Maurer explains what AKS on bare metal is and where it fits for on-premises, edge, and sovereign deployments, focusing on how it keeps the AKS experience while running directly on physical hardware. He also outlines a deployment path using Azure Local SFF with Arc-based management.

Rob Bos shares a curated set of GitHub governance references he regularly sends to teams, covering enterprise platform baselines, GitHub Actions supply-chain controls, GitHub Advanced Security rollout and triage practices, and GitHub Copilot governance topics like premium requests, extension governance, and MCP-related security notes.

Hidde de Smet breaks down why spec-driven development can either reduce risk or quietly add “delivery debt”, especially in regulated environments. He outlines six common process cost centers, a three-lane model (full/light/no-spec), and a small set of KPIs to tell when structure is paying off.

DevClass reports on GitHub briefly offering to mail a CD-ROM copy of a public repository via a Microsoft Form, then pulling the offer after confusion and ridicule. The piece highlights how the stunt intersected with developer concerns about GitHub reliability, repo sizes, and long-term access to source code.

Andrew Lock explains how .NET 11 improves System.Diagnostics.Process output handling to avoid stdout/stderr deadlocks, and introduces new APIs for capturing text, lines, and bytes from child processes with simpler sync and async patterns.