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

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

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

Di: Mirko Peters (Microsoft 365 consultant and trainer)
Ascolta gratuitamente

3 mesi a soli 0,99 €/mese

Dopo 3 mesi, 9,99 €/mese. Si applicano termini e condizioni.

A proposito di questo titolo

 Welcome to the M365.FM — your essential podcast for everything Microsoft 365, Azure, and beyond. Join us as we explore the latest developments across Power BI, Power Platform, Microsoft Teams, Viva, Fabric, Purview, Security, and the entire Microsoft ecosystem. Each episode delivers expert insights, real-world use cases, best practices, and interviews with industry leaders to help you stay ahead in the fast-moving world of cloud, collaboration, and data innovation. Whether you're an IT professional, business leader, developer, or data enthusiast, the M365.FM brings the knowledge, trends, and strategies you need to thrive in the modern digital workplace. Tune in, level up, and make the most of everything Microsoft has to offer. M365.FM is part of the M365-Show Network.

Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.Copyright Mirko Peters / m365.fm - Part of the m365.show Network - News, tips, and best practices for Microsoft 365 admins Politica e governo
Episodi
  • Beyond SELECT: Why T-SQL Still Shapes Modern Data Strategy

    Beyond SELECT: Why T-SQL Still Shapes Modern Data Strategy
    Jan 10 2026
    Most organizations believe modern platforms like Microsoft Fabric made SQL optional. This episode explains why that belief is dangerously wrong. T-SQL didn’t disappear—it moved upstream, into the layer where cost overruns, security drift, performance incidents, and audit findings are created long before anyone notices them. “Beyond SELECT” doesn’t mean beyond SQL; it means beyond responsibility. This episode reframes T-SQL as what it really is in modern data platforms: a contract language for enforcing intent—truth, access boundaries, and predictable compute—in systems that otherwise drift into entropy. If your cloud costs feel random, your dashboards disagree, or your security model depends on “temporary exceptions,” this episode explains why. What You’ll Learn 1. Why “Beyond SELECT” Is About Responsibility, Not Features Modern data stacks optimize for convenience and throughput, not intent. Without explicit relational contracts—schemas, constraints, permissions, and validation—data becomes negotiable, not deterministic. 2. How SQL Actually Executes (and Why It Breaks Expectations) SQL reads like English but executes like a compiler. Understanding true execution order explains:
    • Why TOP doesn’t make queries cheaper
    • Why joins multiply cost
    • Why filtering late creates invisible IO bills
    Execution plans—not query text—are the real truth. 3. Execution Plans as Governance, Not Troubleshooting Execution plans forecast cost, risk, and blast radius. This episode reframes plans as governance artifacts:
    • Estimated vs actual plans
    • Why scanned vs returned rows matter
    • How spills, sorts, and join choices predict incidents
    A plan you can’t predict is a budget you can’t control. 4. Fabric Entropy: When Lakehouse Inputs Become Warehouse Liabilities Schema-on-read without enforcement becomes schema-never. The result:
    • Dirty data silently loads
    • Fixes spread into Power BI, DAX, Power Query
    • Multiple “truths” emerge
    T-SQL constraints and validation gates stop chaos at the boundary—before it becomes a BI argument. 5. Parameter Sniffing: Your Cloud Bill’s Favorite Feature Stable code can still produce unstable cost. This episode explains:
    • Why parameter sniffing creates “random” slowdowns
    • How cached plans turn historical samples into policy
    • Trade-offs between recompilation, plan generalization, and branching
    The goal isn’t fast queries—it’s stable ones. 6. Security Debt in Fabric: Always On ≠ Always Correct Workspace roles are not data contracts. Without database-layer permissions:
    • Least privilege erodes
    • Audit answers become vague
    • Temporary access becomes permanent
    T-SQL schemas, roles, and deny-by-default design are what make security survivable. 7. Business Logic Drift: The Quiet Killer When logic lives in Power BI, pipelines, notebooks, and apps simultaneously:
    • Trust erodes
    • Performance degrades
    • Audits become theater
    Centralizing logic in views and stored procedures turns definitions into enforceable contracts. 8. Indexing, Partitioning, and Structural Redesign You’ll learn when:
    • Indexing fixes access-path problems
    • Partitioning enforces storage-level discipline
    • Query tuning stops working and redesign is required
    Not every problem is a query problem—some are system-shape problems. 9. AI & Copilot SQL: Speed Without Governance AI writes queries instantly—but not contracts. This episode explains:
    • Why AI-generated SQL accelerates entropy
    • Common AI failure modes (non-sargable filters, bad joins, SELECT *)
    • How execution plans become acceptance gates for AI output
    AI drafts. Humans govern. Core Takeaway T-SQL isn’t about retrieving data. It’s about enforcing intent. In Fabric-era platforms, systems decay unless governed. T-SQL remains the control surface where shape, access, and cost become enforceable—before entropy turns into outages, spend spikes, and security debt. Call to Action T-SQL is the difference between a deterministic platform and a probabilistic one.
    If you want the next layer, watch the follow-up episode on reading execution plans as risk signals. Subscribe—this channel assumes platforms decay unless governed.

    Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.
    Mostra di più Mostra meno
    53 min
  • The Silent Crash: Why Your Platform is Rotting from the Inside

    The Silent Crash: Why Your Platform is Rotting from the Inside
    Jan 9 2026
    It’s 03:47 UTC. The IT team is asleep—but the platform isn’t. In this episode, we explore a familiar late-night mystery in modern IT: unexplained SharePoint lists, silent permission changes, failing Power Automate flows, and the slow accumulation of governance debt. What starts as a few harmless “test” artifacts quickly reveals deeper structural issues hiding inside everyday platforms. Through a narrative walkthrough and practical analysis, we unpack how well-intentioned platforms drift over time—and what disciplined governance actually looks like when the pressure is on. What You’ll Learn
    • How small, ignored platform behaviors compound into serious risk
    • Why “temporary” solutions are a leading cause of long-term technical debt
    • The hidden cost of unmanaged SharePoint lists and Power Platform sprawl
    • How permissions, automation, and ownership quietly fall out of alignment
    • What real platform governance looks like beyond policies and diagrams
    Key Topics Covered
    • Platform drift and governance debt
    • SharePoint list sprawl
    • Power Automate failure patterns
    • Permission changes without change control
    • Ownership, naming conventions, and lifecycle management
    • Why documentation alone doesn’t scale
    • Discipline as a governance strategy
    Memorable Quotes “Nothing here is technically broken—yet everything is wrong.” “Governance debt accumulates the same way technical debt does: quietly, incrementally, and usually with good intentions.” “Platforms don’t fail loudly. They fail gradually.”

    Who This Episode Is For
    • IT leaders and platform owners
    • Microsoft 365 and Power Platform administrators
    • Architects dealing with platform sprawl
    • Anyone inheriting “working” systems they don’t fully trust
    Call to Action If this episode felt uncomfortably familiar, it might be time to audit not just your platform—but the assumptions behind how it’s governed. Subscribe for more deep dives into the real mechanics of modern platforms, technical debt, and operational discipline.

    Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.
    Mostra di più Mostra meno
    11 min
  • Microsoft Copilot Multi-Agent Orchestration: Enforce Determinism, Unlock ROI

    Microsoft Copilot Multi-Agent Orchestration: Enforce Determinism, Unlock ROI
    Jan 9 2026
    Enforce Determinism. Unlock ROI. Agent sprawl isn’t innovation. It’s unmanaged entropy. Most organizations believe that shipping more Copilot agents equals more automation. In reality, uncontrolled multi-agent systems create ambiguity, governance debt, and irreproducible behavior—making ROI impossible to prove and compliance impossible to defend. In this episode, we break the comforting myth of “AI assistants” and expose what enterprises are actually deploying: distributed decision engines with real authority. Once AI can route, invoke tools, and execute actions, helpfulness stops mattering. Correctness, predictability, and auditability take over. You’ll learn why prompt-embedded policy always drifts, why explainability is the wrong control target, and why most multi-agent Copilot implementations quietly collapse under their own weight. Most importantly, we introduce the only deployable architecture that survives enterprise scale: a deterministic control plane with a reasoned edge. 🔍 What We Cover • The core misunderstanding You’re not building assistants—you’re building a decision engine that sits between identity, data, tools, and action. Treating it like UX instead of infrastructure is how governance disappears. • Why agent sprawl destroys ROI Multi-agent overlap creates routing ambiguity, duplicated policy, hidden ownership, and confident errors that look valid until audit day. If behavior can’t be reproduced, value can’t be proven. • The real reason ROI collapses Variance kills funding. When execution paths are unbounded, cost becomes opaque, incidents become philosophical, and compliance becomes narrative-based instead of evidence-based. • Deterministic core, reasoned edge You can’t govern intelligence—you govern execution. Let models reason inside bounded steps, but enforce execution through deterministic gates, approvals, identity controls, and state machines. • The Master Agent (what it actually is) Not a super-brain. Not a hero agent.
    A control plane that owns:
    • State
    • Gating
    • Tool access
    • Identity normalization
    • End-to-end audit traces
    And stays intentionally boring. • Connected Agents as governed services Enterprise agents aren’t personalities—they’re capability surfaces. Connected Agents must have contracts, boundaries, owners, versions, and kill switches, just like any other internal service. • Embedded vs connected agents This isn’t an implementation detail—it’s a coupling decision. Reusable enterprise capabilities must be connected. Workflow-specific logic can stay embedded. Everything else becomes hidden sprawl. • Real-world stress tests We walk through Joiner-Mover-Leaver (JML) identity lifecycle and Invoice-to-Pay workflows to show exactly where “helpful” AI turns into silent policy violations—and how deterministic orchestration prevents it. 🧠 Key Takeaway This isn’t about smarter AI.
    It’s about who’s allowed to decide. Determinism—not explainability—is what makes AI deployable. If execution isn’t bounded, gated, and auditable, you don’t have automation. You have a liability with a chat interface. 📌 Who This Episode Is For
    • Enterprise architects
    • Identity, security, and governance leaders
    • Platform and Copilot owners
    • Anyone serious about scaling AI beyond demos
    🔔 What’s Next In the follow-up episode, we go deep on Master Agent routing models, connected-agent contracts, and why routing—not reasoning—is where most “agentic” designs quietly fail. Subscribe if you want fewer vibes and more deployable reality.

    Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.
    Mostra di più Mostra meno
    53 min
Ancora nessuna recensione