M365.FM - Modern work, security, and productivity with Microsoft 365

You know what’s truly horrifying? A Power BI gateway that works flawlessly in your test tenant—green checks everywhere, dashboards refreshing like a dream—then completely collapses in production because the one outbound firewall rule that actually matters was never opened. In this episode, I break down the real communication architecture of the gateway, how test tenants lull you into a false sense...

Let’s be real—Teams channels are just three kinds of roommates. Standard channels are the open‑door living room, Private channels are the locked bedroom, and Shared channels are when your roommate’s cousin “stays for a few weeks” and suddenly your fridge looks like a crime scene. The problem isn’t the labels, it’s treating all three like the same thing: by the end of this episode, you’ll know exac...

Your SPFx web part looks great—but if it’s not pulling live data, users will treat it like a lobby poster: nice to look at, useless to trust. In this episode, we walk through three concrete wins you can actually ship this month: connect SPFx securely to Microsoft Graph and SharePoint without an OAuth death march, make calls faster with selective payloads, caching, and throttling‑aware patterns, an...

One wrong Purview retention rule can chew through your storage like Pac‑Man on Red Bull—locking files, bloating preservation copies, and turning your intranet into a haunted house of “can’t delete” errors. In this episode, I break down what Purview really is (your tenant’s compliance inspector), why it’s not “just IT’s problem,” and how bad information architecture turns it from a precision tool i...

Your Teams notifications are dumb. They spam reminders nobody reads and look like they were designed in 2003. In this episode, we fix that by walking through three pieces: structuring your data in Microsoft Lists, designing an Adaptive Card that’s actually clickable, and wiring it together with Power Automate so users can act directly in chat. Once those pieces connect, boring alerts turn into min...

Admins, remember when Power BI Premium felt like your biggest headache? Overnight you became Fabric admins, staring at domains, workspaces, and capacities like an IKEA manual written in Klingon. In this episode, we unpack why Microsoft’s promise of “simpler organization” actually means more moving parts, and how you can still build something stable: clear domain taxonomy, purpose‑driven workspaces...

Have you ever written a LINQ query that worked perfectly in C#, but when you checked the SQL it generated you wondered how it turned into that monster? In this episode, you’ll learn how expression trees control translation, how EF Core’s query provider decides what becomes SQL and what falls back to client‑side evaluation, and how caching quietly shapes performance and memory use. We also dig into...

Ever notice how the fastest way to ship is usually the messiest—logging scattered through controllers, validation copy‑pasted into handlers, authentication bolted on wherever it happens to work? It feels fast in the moment, but every shortcut adds weight until the codebase becomes something nobody wants to touch. In this episode, we look at why dirty code wins the short‑term race, how cross‑cuttin...

If your Power App exposed sensitive data tomorrow, would you know why—or how to shut it down? No-code feels fast, but every skipped checkpoint quietly adds risk; pro-code gives you control, but only if you deliberately design and maintain security yourself. In this episode, we compare how both models handle speed, guardrails, governance and long‑term ownership so you can decide which approach fits...

Most people still think of ASP.NET Core as “just” a web framework, but .NET 10 quietly ships with an AI‑ready engine that shapes how your apps think, react and secure themselves. In this episode, I unpack what that actually means: how AI hooks integrate with the runtime, how WebAuthn passkeys and modern security signals feed into your telemetry, and how improved diagnostics can surface problems ea...

If a new hire joined tomorrow, how long would it take them to find the files they actually need—ten seconds, ten minutes, or never? In this episode, we show why neat site diagrams and folder trees create the illusion of control while people still ask “Where’s the latest version?” or “Should this live in Teams or SharePoint?”. You’ll learn the three layers of content assessment most teams skip—stru...

How many hours have you lost wrestling with configs, auth wiring and deployment scripts before writing a single useful line of code? In this episode, we start from that pain and then flip the script: you’ll see how GitHub Copilot for Azure knocks down the blank‑page problem by scaffolding infrastructure‑as‑code from a simple prompt, and how the Azure Developer CLI (azd) turns that scaffolding into...

Quantum computing sounds like lab‑coat physics, but today you can write Q# on your laptop and send it to a real quantum computer in the cloud. In this episode, you see the full path: from installing the Quantum Development Kit and Q# tools, to running a simple program locally, to submitting the same job to Azure Quantum hardware. We focus on what feels familiar to .NET and cloud developers—project...

You were promised speed, savings and security in one move to the cloud—and got half‑finished migrations, surprise bills and endless “stabilization” instead. In this episode, I explain why cloud migrations never really end, how the data you collect turns into busywork instead of decisions, and where responsibility for fixing things quietly evaporates between teams. You’ll get concrete targets you c...

If you’re using Entity Framework only to mirror your database tables into DTOs, you’re missing most of what it can actually do. That’s like buying an electric car and never driving it—just plugging your phone into the charger. No wonder so many developers end up frustrated, or decide EF is too heavy and switch to a micro‑ORM. In this episode, I walk through a concrete before‑and‑after refactor, th...

You fix a tiny function, all unit tests go green, the pipeline smiles—and production still breaks in three different places. That’s not bad luck, it’s a missing test strategy: each layer (unit, integration, front‑end) catches a different class of failure, but most teams over‑invest in one and under‑invest in the others. In this episode, we use a real Azure Functions bug as the running example: how...

ARM templates look powerful on paper—but in real projects they grow into giant JSON blobs that are hard to read, harder to debug, and almost impossible to keep in sync with what’s actually running in Azure. One missing comma or brace can block a whole deployment, error messages are vague, and teams under pressure quietly “fix it in the portal,” leaving templates and reality out of sync. In this ep...

If you think your .NET app is “secure enough” just because you’re on the latest framework, this episode is your uncomfortable reality check. OWASP’s upcoming 2025 update shifts focus away from the usual suspects and toward architectural and ecosystem risks that can compromise your app even when your controllers and queries look clean. We unpack which new categories hit .NET teams hardest—supply ch...

The Power Platform will take you a long way—but not all the way. When workloads get heavy, logic gets complex, or integrations become high‑throughput, flows that looked great in testing start to stall, time out, or buckle under throttling. In this episode, we walk through where Power Apps and Power Automate quietly run out of steam, how to spot the warning signs early in your run histories, and ho...

Passwords aren’t failing because users are careless—they’re failing because the model is fundamentally outdated. Phishing, credential stuffing and endless resets show how fragile a system is that still depends on humans remembering secrets at internet scale. In this episode, you’ll see why tightening password policies barely moves the needle, how much breaches and resets really cost your organizat...

If you’ve been comfortable living inside Power BI, Fabric quietly moved the ground under your feet. Power BI alone is no longer the full story—it’s now just one surface on top of OneLake, pipelines, warehouses, KQL and real‑time analytics. In this episode, we start from the “classic” BI workflow (scheduled refresh, static snapshots, report‑only mindset) and show how Fabric turns you from a visual...

What happens when the software you rely on simply doesn’t show up for work—on the last day of the month, during a critical reporting cycle, or right before a client deadline? A single failed Power App submission or broken Intune policy can leave entire teams locked out, while your service agreements quietly state that the time, money and stress you lose are still your problem. In this episode, we...

Clicking through the Azure portal works for one‑off fixes, but it falls apart when you need repeatable, reliable changes across multiple environments. In this episode, we take your real‑world pain—late‑night portal tweaks, configuration drift, and “it worked in staging” moments—and turn it into a practical automation strategy with Azure CLI and PowerShell. We start with the trap of the portal: why...

What if your DevOps team gained a tireless new teammate who understands your entire stack, remembers every decision, and quietly handles the grunt work in the background? That’s what Agentic AI promises: a shift from simple autocomplete to coordinated AI agents that plan, adapt and collaborate across code, infrastructure and pipelines. In this episode, we unpack what makes Agentic AI different fro...

In 1975 you programmed an Altair 8800 by flipping switches and watching LEDs; in 2025 you click once and Azure spins up global infrastructure, AI models and multi‑tenant services in seconds. The surface looks completely different, but the underlying ideas—shared resources, programmable access, centralized capacity—never really went away. In this episode, we use the story of the Altair and classic...