Episodes

Copilot didn’t hallucinate — you hallucinated first. Your schema lied → Fabric believed it → Copilot repeated it with confidence. Bad Bronze → leaky Silver → fake Gold = executive decisions built on fiction. Fix the Medallion discipline + fix the semantic layer — or keep paying for an AI that politely invents your reality.

Power BI isn’t failing because of visuals — it’s failing because nobody plans. 60–70% of BI projects become expensive wallpaper. This episode exposes the 3 discipline steps that separate strategic intelligence from dashboard vanity — why most organizations confuse activity for progress, and how to finally stop the “successful failure” of Power BI.

You Thought Your Power BI Maps Were Safe breaks down the Bing Maps → Azure Maps eviction — and why this is not optional, not cosmetic, and not “a visual upgrade.” As of Oct-2025, Bing Maps visuals are deprecated. If you don’t migrate, your map visuals become blank boxes. This episode explains what’s actually changing, why Azure Maps is a compliance-era replacement — not a skin swap — and the admin switches you MUST flip in the tenant before anything works. We cover the migration traps, the false comfort of “auto convert,” and the difference between visuals that render and visuals that survive production. This is not a warning — it’s a countdown.

Power BI Collaboration — from Wild West → Hub-and-Spoke Power BI self-service feels empowering… until every department defines “revenue” differently and no one agrees which dashboard is real. In this episode, we break down why the chaos isn’t a tooling problem — it’s an architecture problem — and how the Hub-and-Spoke model fixes it. We walk through how to create one shared semantic truth (the Hub) — with certified datasets, owners, refresh discipline, and version control — while still letting departments move fast in their own exploration spaces (the Spokes). This is the roadmap to move your analytics org from “faith-based metrics” to governed trust.

Dataverse isn’t “included.” It’s a premium, enterprise-grade platform with costs that stack fast: licenses, capacity, environments, storage (db/file/log), and API limits. Most sticker shock comes from assumptions—thinking M365 covers Dataverse, that guests are free, or that storage is cheap. Use Dataverse when governance, security, and relational consistency truly matter. Otherwise, cheaper setups (SharePoint Lists, SQL, or hybrid) deliver ~80% of the value without premium connectors or capacity burn. The mature play: prototype on Lists/SQL, graduate to Dataverse only when scale, audit, and security demand it. Dataverse is powerful and pricey by design. Treat it as a graduation platform, not a default. Budget first, then build.

Copilot Notebooks feel magical — a conversational workspace that pulls context from SharePoint, OneDrive, Teams, decks, sheets, emails — and synthesizes answers instantly. But the moment users trust that illusion, they generate data that has no parents. Every Copilot output — a summary, paragraph, bullet list — is derived content that contains fragments of sensitive sources… but inherits none of the original sensitivity label, retention policy, audit trace, or Purview detection scope. Result: enterprises are silently creating a Shadow Data Lake — an ocean of unlabeled, untraceable derivative insight. The core problem isn’t Microsoft’s security model — it’s that governance frameworks assume lineage, and AI isn’t generating lineage. Solution: treat AI output as first-class content. Label by default. Apply Derived Data policies. Time-box Notebook containers. Limit sharing. Make AI summaries review-gated. AI productivity accelerates — and so does compliance debt — unless…

Most Microsoft Fabric teams are bleeding money because they treat Dataflows Gen2 like old Power BI ETL. In Fabric, compute—not storage—is the meter, so every redundant refresh spins up clusters, reloads the same sources, and multiplies cost. The fix is architectural, not heroic CSV exports. There are only three sane patterns: Bronze / Staging — land external data once into Delta (incremental where possible). Everyone else references, no re-ingestion. Silver / Transform — centralize business logic and data quality. Build computed entities, enforce semantics, and chain flows to bronze for clean lineage. Gold / Serve — expose curated Delta to consumers (Direct Lake semantic models, shared tables). No import refreshes, no duplication, low latency. Choose based on cost, governance, and speed. Small teams: bronze + thin silver. Enterprises: full bronze/silver/gold with centralized orchestration. Mixed mode: bronze+silver for builders, minimalist gold for exec reporting. Bottom li…

Fabric didn’t fail at features—it failed at governance cohesion. Data lives in Fabric, security sits in Power BI, labels live in Purview—and they don’t natively reason about each other. That’s why audits devolve into CSV marathons and name-matching nightmares. Enter GPT-5 inside Microsoft 365 Copilot. The leap isn’t speed; it’s reasoning. GPT-5 infers relationships across Fabric lineage, Purview classifications, and Power BI security—then validates them as one logical story. Ask, “Which Lakehouse tables with PII lack Purview labels and Power BI RLS?” It reconstructs lineage, cross-checks labels, inspects roles, and returns a verified, explainable result—no manual triangulation. The payoff: governance shifts from reactive, episodic audits to predictive, continuous assurance. Costs drop (fewer human hours and mistakes), confidence rises (explanations with evidence), and scale improves (one reasoning loop supervises thousands of assets). Implement via Copilot Studio: enable GPT-5 (…

GPT-5 in Copilot is dazzling—but its fluency can fool you. It produces executive-ready prose fast, yet lacks defensible provenance. That makes it great for creation (drafts, outlines, brainstorming) and terrible for compliance (anything that must survive audit). The Researcher Agent is the counterweight: slower, source-driven, and methodical. It asks clarifying questions, fetches and cites sources, logs retrieval, and builds an auditable chain of reasoning. In regulated environments, that difference is existential: GPT-5 gives velocity; the Agent gives veracity. Use Copilot for momentum; use the Agent when lineage, citations, and reproducibility are mandatory—governance docs, financial/regulatory reporting, internal knowledge articles, Entra/security audits, and exec-level market analysis. The winning pattern is a hybrid workflow: ideate with Copilot → verify critical claims with the Agent → reintegrate citations and let Copilot polish language. Keep layers separate to avoid “governan…

The SharePoint Knowledge Agent is marketed as an autonomous librarian; in practice, it’s an overconfident intern that needs supervision. It can suggest metadata, set simple natural-language rules, and answer questions across libraries—but it amplifies whatever chaos already exists. Auto-tagging mirrors your inconsistencies (duplicate/variant columns), rules fire unreliably (timing/indexing fragility), and chat answers can surface sensitive or misleading content because fluency ≠ judgment. The biggest hidden risk is metadata inflation and AI drift: casual prompts quietly spawn new columns and rules, fragmenting taxonomy and contaminating Copilot results downstream. The fix isn’t to ban it—it’s to sandbox and govern it: run pilots in curated libraries, review every suggested column, lock naming conventions, monitor column/rule creation, and gate publication. Used deliberately, it speeds broad classification and search. Used as “autopilot,” it manufactures governance debt at machine spee…

Most “analysis” in Excel is disguised janitorial work: inconsistent dates, mixed data types, rogue spaces, and copy-pasted chaos that later poisons Power BI, Power Automate, and Fabric. The fix isn’t heroics—it’s Excel Copilot acting as an AI janitor that understands structure, enforces types, and prepares data for downstream systems. Two modes matter: Chat (diagnose, explain) and App Skills (actually change the sheet). The practical playbook: 1) Normalize Everything (types, dates, casing, spaces, IDs), 2) Validate & Flag Outliers (rules for missing/absurd values, deviation checks), 3) Transform for Integration (summaries, tidy tables, headers for Power BI/Flows). Once clean, Copilot upgrades sheets from neat to smart—sentiment tagging, segmentations, “Think Deeper” diagnostics—then hands results straight to Power BI/Power Automate without brittle CSV shuffles. The manual phase is over: treat Copilot as a preprocessor at data intake, codify cleanup as prompts, and promote analysts fro…

Power Apps forms turn knowledge workers into typists—rigid fields, copy-paste from emails/PDFs, and slow, error-prone decay that pollutes Dataverse, Power BI, and downstream automations. The fix isn’t more validation; it’s an interpreter: the AI Data Entry Agent. Inside model-driven apps, it converts unstructured input (Smart Paste) and file uploads (OCR) into clean, schema-aligned records—with source snippets, confidence cues, and your existing validation rules enforced. Complex cases shine: multi-address suppliers, related child tables, and certifications become structured data in seconds, not spreadsheets. Architecture matters: entity extraction → schema alignment → pre-submit validation, all within tenant boundaries and Dataverse security. Caveats: premium licensing/AI capacity, regional compliance, domain jargon limits, and “it maps to what exists” (no auto-schema). Roll out with guardrails—pilot libraries, telemetry, naming sanity—then scale. Net result: forms stop demanding typ…

Enterprises reflexively “modernize” by migrating data—Lists → Dataverse → Fabric—burning time and budget to recreate what already works. The myth: Copilot needs data moved to “enterprise-class” stores. The reality: Copilot Studio now connects directly to SharePoint Lists—live, permission-aware, no ETL, no duplication. Authentication replaces replication. Governance is inherited (same ACLs/MFA/audit), risk drops (fewer copies), and answers reflect real-time list updates. Performance? Modern Lists scale when designed sanely (index columns, filter views); slowness is usually architecture, not platform. When to migrate: high-velocity transactions, strict relational integrity, or ERP-grade complexity. Otherwise, keep Lists where business actually happens and let Copilot converse with them. Strategically, Lists flip from “pre-database staging” to living knowledge cells—departmental truth that Copilot queries on demand (up to ~15 lists per agent). New commandment: stop moving data; start con…

Canvas Apps gave pixel freedom but bred fragility: endless containers, brittle Power FX, and hours lost to layout therapy while data modeling and governance languished. The game has changed. Generative Pages inside Power Apps shift creation from craft to command: you describe intent (“ideas tracker with category filters and a bar chart”), and AI generates responsive, accessible, Dataverse-aware pages on a React stack—prewired CRUD, filters, charts, theming, and role-respecting security. The App Agent iterates via natural language, producing reversible diffs instead of formula spaghetti. Architecture—not artistry—drives speed, consistency, and scale: schema-aligned components, tokenized theming, built-in accessibility, and versionable changes. Developers don’t vanish; they graduate—owning schema, governance, performance, and policy while AI handles layout. Keep Canvas for quick sketches or ultra-bespoke surfaces; use Generative Pages for production apps that must be maintainable and co…

Generative Pages feel “free” because they turn a sentence into a working Power Apps page. But the instant you click Generate, you’re on Dataverse—and that’s premium land: governed data, model-driven scaffolding, audit, flows, and a license bill. The UX hides the escalation: scaffolding a React page bound to Dataverse flips your app from “standard” to premium, meaning every viewer needs Premium licensing. “Virtual tables from SharePoint” don’t dodge costs either—they’re Dataverse artifacts brokering CRUD through premium plumbing. Trials and mixed environments mask spend until day-31 pop-ups and admin dashboards light up. The fix isn’t abstinence; it’s intentional architecture: reserve Dataverse for real relational needs, isolate premium into dedicated environments, keep virtual tables read-only, lock sharing until finance signs off, and monitor usage/capacity monthly. Generative Pages are outstanding accelerators—speed with structure—but there’s no “free lunch.” Build fast, review fast…

“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…

“Low-code for everyone” was a great story—but the sequel is Vibe Code: Power Apps Code Apps (React + TypeScript + Git) living inside the same governed Power Platform. Low-code (Canvas/Model-Driven) still wins for speed and business-led prototyping, but it hides complexity, fragments UI, and resists reuse and source control. Vibe Code restores software discipline: VS Code, CLI, packages, PRs, CI/CD, and Entra-backed auth—while keeping connectors, policies, and Dataverse security. Add GitHub Copilot and you get startup-level velocity without surrendering architecture; AI writes scaffolds, you own semantics. The playbook isn’t either/or: prototype in low-code, harden in code; let Copilot accelerate both. Choose low-code for departmental workflows and quick wins; choose Vibe Code for custom UX, performance, reuse, and longevity. The future is a governed spectrum—Copilot + Dataverse + extensibility—where intent becomes deployable assets under one policy spine. “Low-code for everyone” was t…

Stop calling everything “AI automation.” In the Power Platform, workflows and agents are different species. Power Automate flows are deterministic: fixed triggers, ordered steps, predictable outcomes—excellent for compliance and repetition, terrible at ambiguity. Copilot Studio agents are autonomous within guardrails: they reason toward goals, choose tools at runtime, adapt to context, and escalate when uncertain. That shift—from scripting steps to supervising intent—changes governance, auditing, and risk. At scale, thousands of unsupervised flows collide; poorly bounded agents can improvise into chaos. The winning architecture is hybrid: agents interpret, decide, and delegate execution to auditable workflows. Use flows for transactional muscle memory; use agents for judgment, language, and cross-system synthesis; bind them with Agent Feed visibility and connector policies. Design for supervised autonomy: capability envelopes, role-scoped tools, and reviewable decision trails. The que…

Your “smart” flow didn’t fail because of AI—it failed because it trusted unvalidated input. Automation amplifies bad data at machine speed: blank fields, sloppy emails, vague purposes become corrupted Dataverse rows, bogus approvals, and dashboards that lie confidently. The fix isn’t “more AI,” it’s governance—specifically, Request for Information (RFI) in Copilot Studio. RFI is the human firewall: a synchronous pause that sends an Outlook actionable message, collects required fields, records who confirmed what and when, and only then resumes the flow. Pair RFI with AI validation and you get a governance loop: AI detects gaps, RFI enforces accountability. Result: fewer null loops, defensible audit trails, and data that’s usable downstream. Use workflows for repeatable steps, agents for reasoning, and RFI to stop garbage from entering the system. Speed without validation is just faster failure; RFI converts automation from “hopeful” to audit-ready.

Approvals die in inboxes. Copilot Studio’s Agent Flows flip the script by letting AI act as the first approver, enforcing policy instantly and escalating only edge cases to humans. You design a multi-stage flow: an AI stage evaluates objective rules (amount, category, dates) and—optionally—cross-checks receipts via document input. Clear cases are auto-approved; ambiguous or high-risk ones route to a manual stage (manager, then compliance) with dynamic conditions (e.g., extra review ≥ $150). Everything runs on Dataverse with auditable logs: decisions, inputs, timestamps, and identities. The result is speed and oversight—days to minutes, fewer errors, and approvals that stand up in audits. The playbook: write deterministic prompts, wire dynamic inputs, add targeted human gates, validate documents, and harden with testing/versioning. Bottom line: let AI handle rules; let humans handle judgment. Stop waiting on queues—let logic lead.

Generative Pages feel like low-code’s endgame: describe a page, get React that talks to Dataverse, ship in minutes. The trap is hidden in one click—Edit Code. The second you crack open JSX, Power Apps stops shielding you. You inherit npm drift, security patches, schema changes, auth gaps, and AI “help” that happily overwrites intent. What looked like empowerment becomes ownership: dependencies, diffs, audits, and break-fix at 3 a.m. Microsoft’s Code Compare isn’t a convenience; it’s an admission you’re debugging now. The way forward isn’t panic, it’s containment: isolate any code-edited app into pro-dev environments, add review gates (linting, scanning, CI), and enforce a one-way-door policy—once edited, always treated as code. Low-code stays for safe, declarative work; fenced pro-code handles the exceptions. The moral: AI can generate pages, but not governance. Power without guardrails multiplies liability. Click “Edit” and you’re the developer—act like one.

Model-Driven Power Apps sell “enterprise-grade” credibility but often deliver ceremony over outcomes. The catch is Dataverse: powerful, yes—but it drags licensing, security matrices, solution layers, environment sprawl, and governance latency into problems that needed a shared list and three notifications. Teams embrace the architecture because it feels serious; then drown in schema tweaks, role puzzles, and dashboards nobody opens. Meanwhile, a Fusion Team using Teams + SharePoint Lists + Power Automate ships the same value in days: simple columns, lightweight lookups, chat-native tabs, adaptive cards, and approvals that people actually see. Scale isn’t a Dataverse slogan; it’s a team behavior—indexed lists, basic archiving, and clear ownership carry thousands of rows just fine. Start light, prove value, graduate only when complexity is real (multi-system, regulated, transactional). The silent killer? “Security” settings that over-restrict—mis-scoped roles/business units that make re…

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…

Most orgs still treat on-prem AD groups as sacred, syncing them to Entra ID and calling it “hybrid.” In reality, those objects are zombies: visible in Entra but ruled by on-prem, which blocks modern governance (dynamic membership, access reviews, APIs) and slows HR-driven provisioning. The fix is recognizing Source of Authority (SoA) per object. Groups that matter to cloud workloads should be cloud-managed (isCloudManaged=true), with Group Writeback used only where legacy systems still need on-prem visibility. Entra brings dynamic rules, self-service, access reviews, and unified audit; AD brings inertia and gray, read-only fields. The path forward: inventory and purge “zombie” groups, classify what stays, finish Exchange migrations, convert eligible security groups to Entra authority, and enable writeback via Cloud Sync for any remaining on-prem dependencies. This isn’t rebellion; it’s alignment—put governance where work happens. Let AD retire into archival role; let Entra run identit…