Microsoft Development Podcast – APIs, Identity & Architecture Episodes

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…

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…

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…

Choosing between low-code, no-code, and pro-code can feel overwhelming, and in this episode we break down exactly what each approach means, how they differ, and when each one is the right fit. You’ll learn how pro-code gives developers full control and unlimited customization, why low-code strikes a powerful balance between speed and flexibility, and how no-code enables business users to build apps without writing a single line of code. We explore real-world use cases, the strengths and limitations of each method, and how organizations are blending these approaches to accelerate development while maintaining quality and scalability. Whether you're trying to empower citizen developers, speed up delivery, or build complex enterprise systems, this episode gives you the clarity you need to choose the right development strategy for your team and your goals.

AI is becoming a first-class citizen in the .NET ecosystem, and in this episode we explore how the new integrated AI Engine in .NET 10 transforms the way developers build intelligent applications. You’ll learn how .NET now provides a unified platform for training models, running inference, orchestrating AI agents, and integrating cutting-edge services like Azure OpenAI and Semantic Kernel directly into your apps. We break down how ASP.NET Core, EF Core, Microsoft.Extensions.AI, and Visual Studio 2026 work together to simplify everything from vector search to workload orchestration, and how developers can use the AI Engine to build smarter, faster, and more responsive applications with minimal friction. You’ll also discover best practices for architecting AI-ready systems, optimizing performance, managing data pipelines, and deploying AI workloads at scale. If you’re ready to take your .NET skills into the next generation and build apps that think, learn, and adapt, this episode gives …

Azure Quantum is opening the door to the next era of computing, and in this episode we explore how Microsoft’s Quantum Development Kit gives developers everything they need to start building and testing real quantum programs today. You’ll learn what Azure Quantum actually is, why quantum computing matters, and how the QDK brings together the Q# language, quantum simulators, Python integrations, VS Code tools, Jupyter support, and cloud-based quantum hardware into a single, developer-friendly platform. We break down how to write and debug your first quantum algorithms, how to use the resource estimator to understand what it takes to run your code on real quantum machines, and how to simulate, optimize, and submit jobs directly through Azure Quantum. You’ll also discover how the QDK connects with open-source libraries, how Microsoft is approaching security in the quantum era, and how you can get involved in the growing community shaping the future of quantum development. If you’re curio…

This episode explains how to dramatically improve Entity Framework performance using practical, proven techniques. It highlights common mistakes that slow systems down and shows exactly how to fix them.You’ll hear real examples of EF performance failures, learn clear steps to optimize queries and memory usage, and get the tools needed to measure your improvements. Topics include diagnosing bottlenecks, writing efficient queries, managing change tracking, batching operations, tuning SQL and indexes, using caching wisely, and applying async or parallel patterns safely.Quick wins include using No-Tracking for read-heavy endpoints, projecting to lightweight DTOs, and profiling to identify the slowest SQL first.It’s designed for backend developers, architects, and anyone dealing with latency or database load issues. One guest even shares a small configuration tweak that reduced production CPU usage by 60% in under ten minutes.Overall, the episode offers practical guidance t…

This episode lays out a practical, reliable automated testing strategy for .NET applications, focused on reducing flakiness, speeding up CI, and improving overall confidence in releases. It’s full of real examples, proven tactics, and tools teams can start using immediately.You’ll learn how to rebalance your test suite using a modern test pyramid, apply smoke and contract tests to catch issues earlier, and decide when to mock dependencies versus using real services like containers or test databases. The episode also covers integrating tests into CI/CD pipelines so they stay fast and trustworthy, plus recommended tooling across the .NET ecosystem.Additional guidance includes how to eliminate flaky tests, make them deterministic, and use meaningful metrics to track improvements. You’ll also get a checklist to assess your current testing approach, patterns that reduce long-term maintenance costs, and case studies showing real reductions in CI time and fewer production issues.…

This episode dives straight into the myth that upgrading to the latest .NET framework somehow makes your application safe, and it dismantles that belief fast. With the OWASP update reshaping how risks are ranked and understood, this conversation exposes why modern attacks no longer target your neat little controller functions but the seams, the glue, and the forgotten corners of your architecture. It breaks down how a fully patched .NET 8 or .NET 9 app can still be quietly compromised through a poisoned NuGet package you never knew your build relied on or a base container layer that slipped into production months ago without anyone noticing. What used to be a checklist is now an ecosystem problem, and that shift is the heart of this episode.Listeners get walked through what OWASP is really signaling: the biggest threats aren’t the old SQL injection classics, even though those never truly disappeared, but the blind spots created by modern development itself. The invisible dependenc…

This episode explores how agentic AI is reshaping DevOps by automating CI/CD, incident response, and cloud operations. It explains why these autonomous systems are gaining so much attention and shares real stories of teams dramatically speeding up deployments. You’ll also learn the risks — including failures, security blind spots, and how to safely revert when automation goes wrong.Listeners will get a practical framework for evaluating agentic AI tools, a checklist for testing autonomous agents in staging, and decision guidance on when to rely on automation versus maintaining human oversight. The episode features surprising case studies, tool comparisons, and straightforward tactics to mitigate new attack surfaces created by AI-driven systems.It’s aimed at SREs, DevOps and platform engineers, CTOs, and researchers working on operational automation. Overall, the episode provides a step-by-step path to adopting agentic AI safely and gaining real benefits from autonomous operati…

This episode walks you through how to take an existing web app and bring it directly into Microsoft Teams so it feels native, seamless and fully connected to Microsoft 365. We break down the Teams Developer Platform and explain how the Teams Toolkit, SDK and App Studio come together to give developers a full-stack path for building modern Teams experiences. You’ll hear how tabs make it easy to embed a web app, how SharePoint and Microsoft Graph unlock deeper integration, and why adding Microsoft 365 Copilot or custom agents can transform a simple embed into an intelligent workflow. We cover the practical realities of setting up your environment, wiring up front-end interactions with the Teams JavaScript client, and building a reliable back end using Node.js or .NET. The episode also highlights how GitHub samples, developer communities and structured learning paths help you go from your first prototype to a polished, production-ready Teams app. It’s a complete guide to turning your web…

This episode explores how Copilot is reshaping the future of Power BI development and what this means for anyone working inside Microsoft Fabric. The conversation opens with the shift from traditional BI workflows to an AI-assisted model, where Copilot becomes a natural part of how developers build reports, write DAX, explore data, and understand complex models. Instead of starting from a blank canvas, developers now have an intelligent partner that responds to natural language, interprets intent, and translates prompts into meaningful code, visuals, and insights.As the episode unfolds, the hosts explain how Copilot works inside Power BI and Microsoft Fabric, emphasizing how generative AI reduces friction across the entire development lifecycle. Writing DAX becomes faster, cleaner, and more approachable. Creating visualizations feels more conversational. Even data preparation gets easier, with Copilot capable of producing Power Query transformations and offering guidance on shapin…

Dev Tunnels in Visual Studio let you expose your local Teams, SharePoint, or Power Platform services to the internet in minutes—no Azure deploys required. Configure a named, persistent tunnel and use Private (authenticated) access tied to Microsoft Entra ID to keep tests secure and your OAuth redirect URIs stable. With real-time feedback in Microsoft 365, you’ll cut iteration loops, avoid “Final_v2” chaos, and standardize setup with the Dev Tunnels CLI. The biggest risk? Leaving a tunnel Public/anonymous—one missed setting can expose your entire dev box. Lock it down, log it, and shut it off when done.

Ever spent hours carefully building a SharePoint site, only to realize the next one looks and behaves completely differently? That frustration comes from manual setup—and it’s almost guaranteed to drift over time. This episode breaks down why hand-built SharePoint sites never stay consistent and how Site Scripts help you take control again. By defining branding, lists, and structure in a single JSON file, you can ensure every new site launches with the same look, layout, and core components, without relying on memory or checklists.But Site Scripts aren’t the whole story. When automation needs go deeper—like setting unique permissions, deploying custom web parts, or handling scenarios Microsoft doesn’t support natively—that’s where PnP PowerShell fills the gaps. Used together, Site Scripts handle predictable structure, while PnP PowerShell enforces the advanced configurations that keep sites secure and usable at scale.The episode also covers the real-world pitfalls of automatio…

Copilot is powerful—but out of the box it sees only Microsoft 365 content, missing the bulk of your organization’s knowledge in legacy wikis, CRMs, ticketing tools, and file shares. The fastest path to business-specific answers is Microsoft Graph Connectors. Unlike narrow plugins or brittle custom integrations, Graph Connectors bring external sources into the Microsoft Graph index with security trimming intact, so Copilot respects existing permissions while surfacing precise, contextual answers. Use connectors to index internal documentation portals, older SharePoint or MediaWiki sites, SQL/line-of-business systems, and platforms like Salesforce or ServiceNow—without risky migrations. The result: fewer “I can’t find it” moments, faster onboarding, and decision-making grounded in institutional memory. This guide explains when to choose connectors vs. plugins/APIs, how connectors work, a step-by-step rollout, and the ROI metrics to track so Copilot finally acts like it knows your busine…

Most Graph-powered apps fail at rollout not because of code, but consent. Dev tenants allow broad testing; production enforces tight policies that block risky scopes. The fix is understanding Graph’s two models—delegated (user-in-context) vs. application (app-only, org-wide)—and requesting the minimum viable scopes that match how your app actually runs. Keep user data to delegated where possible; reserve app-only for unattended or cross-tenant jobs and plan for admin approval. Map tenant consent policies early, stage permissions (pilot → broaden), and document why each scope is required. Use least-privilege alternatives (e.g., Calendars.Read vs. Calendars.ReadWrite, Team.ReadBasic.All vs. full directory). Wrap with governance: pre-approval workflow, quarterly reviews, tagging, and audit logs. Result: fewer “admin consent required” popups, faster security sign-off, and a rollout that survives contact with real users.

Microsoft Fabric’s Git integration isn’t a backup—it’s the backbone of safe, scalable collaboration on notebooks, pipelines, and models. This guide explains why merge chaos happens, what actually syncs to Git (code/metadata) vs. what doesn’t (Lakehouse data), and the one switch that saves teams: adopt a simple dev→test→prod branching model with pull requests. You’ll get a practical playbook to connect workspaces, resolve conflicts, manage environment configs, and keep data parity—so rollbacks are one click, not a week of rework.