Developer Practices Episodes

In this episode of the M365.fm podcast, Mirko Peters explores why many microservice architectures gradually become slower, more fragile, and harder to manage despite originally being designed for speed and agility. What begins as a clean and scalable architecture often turns into a complex web of dependencies where even small feature changes require coordination across multiple services, teams, APIs, and deployment pipelines. The episode explains how distributed systems introduce hidden operational costs that are often underestimated during the early stages of adoption. Network latency, cascading failures, service dependencies, duplicated logic, and excessive inter-service communication can silently reduce development velocity while increasing operational complexity. Instead of accelerating innovation, poorly governed microservice environments can create organizational bottlenecks and technical debt that slow teams down over time. Mirko discusses why architectural decisions shou…

In this episode of the M365 FM Podcast, we explore why modern microservice architectures can quietly become “toxic” under pressure — not because services crash, but because they slow down. A single delayed dependency can silently trigger cascading latency across APIs, queues, databases, and cloud workloads while dashboards still appear healthy. The result is a platform that looks operational on the surface while its real capacity collapses underneath. The episode breaks down how slow dependencies create hidden resource exhaustion inside distributed .NET environments. Long-running requests hold threads, sockets, and connection pools hostage while retries amplify the damage even further. Instead of recovering the platform, poorly designed retry logic often creates synchronized traffic storms that make outages worse. We also dive into why scaling alone cannot solve dependency poisoning. Adding more containers or replicas often just expands the waiting room instead of removing the b…

In this episode of the M365 FM Podcast, Mirko Peters talks with Lukas Pavelka about the future of enterprise app development, AI-assisted coding, and the growing connection between Figma and Microsoft Power Platform. Lukas shares his journey from Java development into building tools like PowerApps for Figma and Power BI for Figma, designed to bridge the gap between modern UI design and low-code development. The conversation explores how Figma has evolved beyond a design tool into a broader ecosystem for prototyping, presentations, reusable design systems, and enterprise application delivery. Lukas explains how his plugins help developers speed up PowerApps creation, improve UI consistency, and even support multi-language app generation across more than 100 languages. A major focus of the episode is AI-driven development and “vibe coding.” Lukas discusses practical experiences with GitHub Copilot, Claude, AI agents, and prompt-based workflows. While AI dramatically accelerates de…

In this episode of the m365.fm podcast, the discussion focuses on using PowerShell to automate tasks across Azure and Microsoft 365 with guest Matthew Dowst MVP. Matthew explains how automation became essential as cloud environments grew more complex and repetitive administrative work increased. The conversation covers how PowerShell can be used to automate common Microsoft 365 and Azure management tasks such as user provisioning, license assignment, reporting, governance, Exchange Online administration, and Entra ID management. Matthew emphasizes that automation should be approached like software development, with proper testing, version control, documentation, and reusable code rather than quick one-off scripts. A major topic is the transition from older AzureAD and MSOnline PowerShell modules to Microsoft Graph PowerShell. Matthew explains why organizations should modernize their scripts and adopt API-based automation to stay aligned with Microsoft’s cloud direction. The e…

This episode explains that most Microsoft 365 governance approaches fail because they rely on static checklists, manual processes, and reporting instead of real enforcement. It argues that governance is not something you “set up” once, but an ongoing operating model that must be built into how the platform actually works. The key message is that if governance is not automated and embedded into identity, provisioning, and lifecycle processes, it will eventually be ignored by users and drift out of control. The episode emphasizes shifting from reactive governance (fixing issues after they happen) to engineered, automated governance that prevents problems by design, with clear ownership, accountability, and continuous enforcement.

This episode explores the shift from traditional collaboration tools to the concept of an enterprise operating system, where platforms like Microsoft 365 unify apps, data, identity, and security into a single architecture. It explains how modern organizations are moving beyond disconnected tools toward integrated digital workplace platforms that define how work happens. You’ll learn what an enterprise operating system is, why this architectural shift matters, and how it impacts enterprise architecture, productivity, and the future of work.

This episode of the M365.FM Podcast — “The Architecture of Persistent Context: Why Episodic AI Is Slowing You Down” — explains that persistent context is not a convenience feature but a foundational architectural layer that determines whether AI systems can scale reliably and productively in the enterprise. The host argues that most organizations treat AI as a “session”, where each interaction starts from scratch based on immediate prompts. This episodic design prevents agents and Copilots from becoming truly effective because context — identity, goals, constraints, history, and provenance — is never carried forward in a structured, auditable, and bounded way. Without persistent context, systems repeat effort, generate inaccurate decisions, and create inconsistencies that amplify risk and operational debt. The episode prescribes architectural principles for implementing persistent context properly — including explicit context boundary definitions, scoped identity tokens, standardized …

This episode explains why attempts to integrate AI into enterprise systems fail not because of model intelligence, but because of unbounded action and brittle integrations. The core claim is that the Model Context Protocol (MCP) is not a plugin system, API wrapper, or merely “standardized function calling”—those descriptions miss the point and lead teams back into the same brittle “AI glue” patterns they want to escape. Custom AI glue—ad hoc connectors, bespoke wrappers, temporary service principals, and middleware—felt reasonable in small projects but, when combined across teams, creates tool sprawl, permission creep, policy drift, and inconsistent logging. These failures are especially dangerous for agentic systems because models fill in gaps confidently. MCP inserts a protocol-level choke point where identity, scope, auditability, and failure behavior can be enforced without trusting the model to behave deterministically. Unlike plugins or function calling conventions that tr…

Your Power Apps app works perfectly, until one day it fails with no error message and users can only say “it spins.” This podcast explains why low-code apps often break in silence: copy-pasted Power Fx formulas drift into conflicting versions, dev and prod blur without real environments, and hidden dependencies (globals, collections, shadow connectors, personal tokens) quietly decide whether the app runs. The transcript highlights common failure triggers like schema renames, delegation changes that drop records without alerts, throttling that causes duplicate submissions, and chaotic sharing that turns permissions into patches instead of roles. The solution is a practical refactor path for resilient Microsoft Power Apps development: map every screen, connector, table, and permission; extract and diff formulas to find duplicated logic; define health thresholds (red/yellow/green) for key user paths; add lightweight telemetry; and rehearse failures in test. The “stop the bleed” patter…

Still writing PowerShell against MSOnline and AzureAD modules in 2025? This episode explains why that stack is legacy – and how to go API-first with pure REST and Microsoft Graph. We walk through the core “token, headers, REST call” pattern, three real-world auth flows (device code, client credentials with certificates, and managed identity), plus the one token audience gotcha that breaks most Graph scripts. You’ll see how to build cross-platform Graph automation that runs cleanly on Linux, containers, GitHub Actions, Azure Functions, and Azure Automation – with no fragile module dependencies. Then we apply the pattern to enterprise scenarios: Intune device cleanup, identity onboarding, and compliance drift detection and remediation, all with least-privilege Graph permissions, robust retry logic, pagination helpers, and full audit trails in Log Analytics. If you’re an Azure, Intune, or Microsoft 365 engineer who’s tired of “works on my laptop” modules, this practical Graph-first…

Stop burning cycles on manual Java upgrades. In this episode, we walk through a real-world, end-to-end modernization of a legacy Java 8 Spring app to Java 21, and show how AI agents quietly do the work your team keeps postponing—with receipts. You’ll hear how we go from a drifting Java 8-era Spring MVC app on AWS (pinned dependencies, unpatched CVEs, idle compute waste, “works on my laptop” folklore) to a faster, cheaper, fully-audited Java 21 runtime on Azure. We let a co-pilot-style modernization agent handle the grind: inventorying the entire stack, ranking CVEs by real reachability, auto-applying OpenRewrite recipes, aligning BOMs, fixing illegal reflective access, and keeping every change traceable in Git. Then we push further: AWS out, Azure in—choosing between Azure App Service vs Azure Spring Apps, migrating to Azure SQL Database, generating production-ready Dockerfiles, wiring GitHub Actions CI/CD, plugging secrets into Key Vault & managed identities, and right-sizing p…

Stop your cloud migration. Seriously. If you’re still bragging about being “cloud first,” this episode will show you why your shiny Azure estate is actually AI hostile. 🧨 We break down the brutal truth: lift-and-shift doesn’t modernize anything—it just moves your technical debt into someone else’s data center. Your VMs won’t give Copilot safe, governed access to data… they’ll give it a front-row seat to your permissions sprawl, lineage gaps, and compliance nightmares. You’ll learn: Why cloud ≠ AI (and how your 2015 migration is blocking 2025 AI use cases) The Fintrax case study: “cloud-first” optics, AI pilot failure, compliance incident, and a 70% cost blowout The 3 pillars of real AI readiness: data discipline, MLOps maturity, and governance talent A no-BS 3-step playbook: Unify → Fortify → Automate so every AI decision becomes traceable and defensible If your roadmap still reads like a relocation plan instead of an AI architecture, hit play before you burn the next dec…

Your Copilot sounds smart but secretly knows nothing about your business. It’s guessing from Wikipedia while your real memory—orders, invoices, inventory—sits locked in SQL Server behind the firewall. This episode exposes the fix: the Power Platform Data Gateway, a locked-down, outbound-only “spinal cord” that lets Copilot read and write live SQL data without exposing your database. You’ll hear how to plug Azure SQL into Copilot Studio as a Knowledge Source so every chat can fire real-time T-SQL through the gateway instead of stale CSV exports. Then it gets wild: SQL Actions turn Copilot from a chatty analyst into a digital employee that can safely insert and update records with confirmations, least-privilege access, and full audit trails. Finally, you’ll blueprint the “hybrid brain”: SQL as memory, the gateway as spine, Copilot + Power Platform as brain, and Teams/Web as the face your users see. With clusters, indexes, telemetry, and a battle-tested checklist, you’ll ship an AI…

Microsoft just made Python “run natively” inside Power Platform — and chaos followed. From Copilot Studio’s Code Interpreter to Azure Functions, everyone’s suddenly a Python dev… until the flows time out, the files hit 512 MB, and IT gets a heart attack. In this episode, we break down the great Python illusion: why “runs natively” ≠ “runs anywhere,” what the Code Interpreter actually is (a sealed glass terrarium for code), and when to stop pretending it’s production infrastructure. Then we contrast it with Azure Functions, the real grown-up runtime — scalable, governed, auditable — and explain how to move from prototype to production without setting your tenant on fire.

“Vibe coding” (Generative Pages) turns plain-English prompts into responsive, Dataverse-aware React pages, replacing the pixel babysitting of manual canvas apps. The upside: speed, consistency, accessibility, and built-in governance via Dataverse metadata and roles. The downside: speed can mask fragility (read-only generated output, prompt ambiguity, hidden licensing), and uniformity shifts technical debt from “messy one-offs” to “platform dependency + regeneration discipline.” Real efficiency comes from standard prompts, governed environments, and treating language like source code. Use manual UI when micro-interaction uniqueness truly matters; use Generative Pages for repeatable, data-driven enterprise apps; blend both for sane delivery: prompt → inspect → refine → redeploy. The verdict: vibe coding isn’t laziness—it’s structural sanity. Measure value in reusable clarity, not artisan pixels. Align on prompt standards, isolate premium usage, and keep Dataverse clean so regeneration s…

Azure File Sync still “works” for many orgs—but on 2010s-era auth: local X.509 certs and SAS tokens. Those are possession-based secrets: whoever holds them is “you.” They sprawl into scripts, backups, repos, and logs; they expire silently; and one leak grants silent exfiltration via valid creds. That isn’t identity—it’s superstition. The modern fix is Managed Identity (MI). Each Storage Sync Service and registered server authenticates through Entra ID with short-lived tokens; no static keys, no cert renewals, no whitelisting of cert endpoints. RBAC replaces secret distribution; revocation is instant; every call is auditable. Migration is housekeeping, not heart surgery: update the File Sync agent, enable system-assigned MI on Azure VMs (or Azure Arc + MI for on-prem/other-cloud servers), flip the Storage Sync Service to MI, and let Azure apply least-privilege roles to the storage account and shares. Outcome: fewer open URLs, zero secrets to rotate, uniform logging, and governanc…

The Microsoft 365 Admin Center is a great map—but it’s not the vehicle. For Copilot and AI governance, clicking through GUI toggles won’t scale, won’t prove compliance, and won’t survive audits. The Admin Center prioritizes visibility; PowerShell delivers authority: bulk actions, reproducible changes, immutable logs, and environment-wide consistency. You argue three big gaps the GUI can’t close: (1) Bulk & repeatability (licenses, DLP, exclusions across tenants and BUs), (2) Governance evidence (who enabled what, when, with which data boundary), and (3) True auditing (inputs/prompts, model access, cross-workload traces). Scripts turn policy from a PDF into enforceable law—scheduled, versioned, and self-documenting. Automation encodes expertise, removes human drift, and creates receipts that pass audits: detect → remediate → validate. The playbook: adopt PowerShell/Graph for inventory and control, wire DLP/RBAC with code, schedule compliance jobs, and export signed audit artifact…

In this episode, we walk through how to integrate with Microsoft Dynamics 365 using its powerful API capabilities, focusing on the REST-based Web API that provides secure and flexible access to CRM data. We start with an introduction to Dynamics 365 as a suite of intelligent business applications and explain how its CRM features—sales, marketing, and customer service—become even more powerful when connected through APIs. You’ll learn about the different API options in Dynamics 365, including the Web API and Organization Service, and why REST APIs are the go-to choice for modern integrations. We cover the essentials of getting started: setting up your Dynamics environment, configuring permissions, authenticating with OAuth 2.0, and making your first API call using standard HTTP methods. The episode also breaks down how to perform key data operations—creating, retrieving, updating, and deleting CRM records—using the Dynamics 365 Web API. We discuss how to handle JSON responses, ma…

In this episode, we dive into how R and SQL Server work together to create a powerful data analytics workflow. You’ll learn why SQL Server excels at storing, organizing, and retrieving large datasets, while R specializes in statistical analysis, visualization, and machine learning. When combined, these two tools streamline data processing, reduce duplication of effort, and enable deeper, more efficient data insights. We explore common use cases—such as running SQL queries from R, analyzing SQL Server data with R’s statistical packages, and using R to create visualizations or predictive models based on SQL data. The episode also walks through how to set up your environment, install the required R packages (RODBC, DBI, odbc, sqldf), and configure ODBC connections so R can query SQL Server directly. You’ll learn best practices for writing SQL queries inside R scripts, using T-SQL features, fetching data into R data frames, and mapping R data types to SQL Server types without losing…

In this episode, we break down how modern development teams can fully automate their CI pipelines using dev containers, container images, and command-line tooling. We explore why containerization has become foundational to DevOps workflows, how development containers ensure consistent coding environments, and how automation tools like Docker, GitHub Actions, and CLI utilities streamline everything from build to deployment. You’ll learn what containers are, why they solve the “works on my machine” problem, and how dev containers—powered by devcontainer.json and VS Code—give developers reproducible, portable workspaces. The episode walks through the core components of a CI pipeline, including source control triggers, automatic builds, container image creation, and deployment stages that rely on Docker and container registries. We explain how Dockerfiles define your application’s build instructions, how base images impact performance and security, and how multi-stage builds can dra…

people often hear the words sql and t-sql thrown around as if they’re interchangeable, and for a while they feel like they are. you write a query, you get your results, and everything seems straightforward. but the deeper you go into database work, the more you notice that not all sql behaves the same, and the moment you start working with microsoft sql server or azure sql, t-sql shows up and quietly becomes its own world. and suddenly the differences matter—not because they’re confusing, but because they’re the key to building things that are faster, safer, and smarter. sql itself is the foundation. it’s the shared language every relational database speaks, the set of rules for selecting data, joining tables, filtering results, and reshaping information. it’s the common grammar behind mysql, oracle, postgresql, and sql server. if sql were a language like english, the basic structure would always be the same everywhere you go. t-sql is what happens when microsoft adds its own di…

Microsoft Fabric Git Integration is changing the game for anyone building modern data platforms, and in this episode we break down exactly how it works and why it matters. Discover how Microsoft Fabric seamlessly connects to Azure DevOps and GitHub, giving you full version control, automated deployments, and a true end-to-end CI/CD workflow for everything from semantic models to Power BI reports. This episode shows how Fabric unifies your data engineering, data warehousing, and analytics tools while Git integration brings collaboration, code tracking, and environment consistency to the entire process. We also explore how Azure DevOps Pipelines and GitHub Actions can automatically build, test, and deploy your Fabric content, helping teams ship updates faster, avoid errors, and maintain total governance across dev, test, and production environments. If you're ready to level up your data operations, streamline deployments, and unlock the full power of Microsoft Fabric with Git, Azure Dev…

LINQ to SQL remains one of the most approachable ways to query and manipulate relational data in .NET, and in this episode we break down exactly how it works, why it’s so powerful, and how it simplifies database interaction compared to traditional SQL and ADO.NET patterns. You’ll learn how LINQ to SQL bridges object-oriented programming with relational data, how Data Contexts map directly to your database schema, and how LINQ expressions are translated into real SQL queries executed by SQL Server. We explore everything from basic selects and filters to advanced joins, grouping, updates, inserts, deletes, and even calling stored procedures through strongly typed methods. You’ll also see how LINQ to SQL compares to LINQ to Objects, how it integrates with the .NET runtime, and how it improves readability, type safety, and maintainability across your entire data access layer. If you want a clear, modern, developer-friendly path to querying databases in C# without manually writing SQL ever…

Writing readable code is one of the most underrated skills in software development, and in this episode we break down exactly why it matters and how developers can master it. You’ll learn what truly makes code readable, how clean-code principles like the Single Responsibility Principle shape maintainable systems, and why consistent formatting and naming conventions can transform even the messiest codebase into something elegant and easy to navigate. We explore how to identify code smells, when and how to refactor, and why continuous cleanup prevents technical debt from silently growing out of control. You’ll also discover how thoughtful commenting, small focused functions, and team-wide coding conventions help every developer write code that is easy to understand, easy to debug, and easy to extend. If you want to level up your craft, write clearer logic, collaborate more effectively, and build software that stands the test of time, this episode gives you the complete roadmap to writin…