Developer Practices Episodes

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…

Local setup shouldn’t be half your job. Aspire promises a single command that spins up your frontend, backend, databases, queues—together—and a built-in dashboard that shows health, logs, and traces across services. In this episode, we run the command, tour the dashboard, and show how it plugs into the stack you already have. Less scavenger hunt, more shipping.

Patchwork debugging steals your day one tiny rebuild at a time. In this hands-on walkthrough, we put GitHub Copilot’s agent mode inside a real .NET + Azure solution and let it hold the cross-file context: updating services, bindings, DI, configs, and infra in one coordinated flow. You’ll see a before/after diff, watch multi-file errors resolve faster, and use a plain-language spec to scaffold a new feature—without losing code review or CI rigor. Bottom line: fewer firefights, more feature work. We keep you in control; the agent just does the heavy lifting.

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.

Stop torturing your laptop. Train models where the data lives. With Microsoft Fabric notebooks running on Spark next to your Lakehouse, you skip CSV exports, move terabytes at query speed, and iterate in Python or R without memory crashes. Push transforms to the data, engineer features at scale, monitor long runs in real time, checkpoint models, and evaluate across massive test sets—cutting days of wrangling into hours of results.

Turn “Where are we on Project Apollo?” into one accurate answer. Build a Copilot plugin that unifies Planner tasks, SharePoint milestones, and Teams context via Microsoft Graph + SharePoint REST, described by a clean manifest and secured with least-privilege Entra ID (Azure AD) OAuth. Result: one question in, one policy-compliant status out—no spreadsheets, no tab-hopping.

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…

Message extensions are the most overlooked productivity feature in Microsoft Teams. Instead of bouncing between apps to paste data, use the right extension for the job: Search extensions surface existing records on demand; Action extensions collect input, trigger back-end workflows, and return results via adaptive cards; Link unfurling turns pasted URLs into rich previews with instant context. The episode walks through building an action-based extension using the Teams SDK and Bot Framework to query external systems (like CRM or ticketing) and post structured, interactive results directly in chat—no context switching. You’ll also learn rollout gotchas: OAuth/SSO, permissions, privacy scope, manifest versioning, tenant-by-tenant deployment, and adoption tips. Pick the extension type that fits the workflow and Teams becomes a decision hub, not a copy-paste log.

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.

Learn how to break Power Apps’ low-code limits by offloading heavy logic, complex integrations, and secure data operations to Azure Functions—without leaving the Microsoft ecosystem. This episode explains when to keep validation and UX in Power Apps, when to move compute to Functions, how to secure calls with managed identities and OAuth, how to design resilient error handling with retries and centralized logging, and how to avoid cost and latency traps. Real-world examples (loan approvals, ERP lookups, pricing engines) show a practical fusion architecture: Power Apps for interface and light workflow, Dataverse for data and governance, Azure Functions for scalable compute and custom APIs. You’ll get patterns, pitfalls, and a step-by-step checklist to ship fast, stay secure, and scale with confidence.

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.

Tired of manual, brittle Power Platform deployments? This guide shows how to build a reliable CI/CD pipeline with Azure DevOps that handles the real trouble spots: environment variables, connection references, service connections, and secure secrets. Learn exactly what a solution package includes (and what it doesn’t), how to parameterize per-environment settings, bind connections after import, and protect credentials with Key Vault. You’ll get a reusable YAML blueprint (build → store artifact → import → set env vars → map connections → smoke test → notify), plus rollback, monitoring, and governance practices so releases are fast, auditable, and drama-free.

Most Microsoft 365 automations fail for the same reason: they rely on fragile delegated permissions tied to human users—leading to session timeouts, MFA prompts, role changes, and broken jobs. The fix is shifting to app-only permissions with Microsoft Graph: run headless, least-privilege, auditable automations via a service principal (no user login, no expiring sessions). This guide shows why delegated breaks at scale, how to set up app-only securely (registration, Application permissions, admin consent, Key Vault secrets), and how to extend it with Graph webhooks for real-time, reliable workflows across SharePoint, Teams, and Outlook—without babysitting logins.

Power Platform chaos across dev/test/prod isn’t inevitable. The Power Platform CLI (PAC CLI) turns fragile, click-heavy moves into repeatable DevOps: scripted solution packaging, versioning, dependency checks, and plug-in registration you can trust. Use PAC CLI to isolate auth per tenant, pack managed solutions with all references, automate plug-in deployments, and wire releases into Azure DevOps/GitHub Actions. Result: predictable migrations, fewer “works in dev” surprises, clean rollbacks, and real traceability—without abandoning the maker portal for day-to-day tweaks.

This episode explains why one-off “thank you” emails from Dynamics 365 (D365) fall flat—and how to replace them with adaptive customer journeys that boost replies, retention, and revenue. You’ll learn how to use D365 signals and Power Automate to trigger timely check-ins, tailored product tips, and honest feedback requests based on real customer actions. We cover which D365 events matter (beyond “case created” and “opportunity won”), how to segment by status changes, purchase frequency, and satisfaction trends, and how to build guardrails like suppression windows and frequency caps. We also show how to close the loop by routing low CSAT to human follow-ups, turning high CSAT into reviews and referrals, and feeding engagement data into continuous improvement via A/B tests and Power BI. If you want emails that start conversations—not end them—this practical walkthrough will help you design dynamic, data-driven flows that keep customers engaged and coming back.