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
  • The Foundational Lie of 'Hire-to-Retire' - Deconstructing the Architectural Debt of Modern HR Systems

    The Foundational Lie of 'Hire-to-Retire' - Deconstructing the Architectural Debt of Modern HR Systems
    Jan 7 2026
    The Foundational Lie of “Hire-to-Retire”
    Deconstructing the Architectural Debt of Modern HR Systems 🧠 Episode Summary Most organizations believe hire-to-retire is a lifecycle. It isn’t. It’s a story layered on top of fragmented systems making independent decisions at different speeds, with different definitions of truth. In this episode, we dismantle the hire-to-retire myth and expose what’s actually running your HR stack: a distributed decision engine built from workflows, configuration, identity controls, and integration glue. We show why HR teams end up debugging flows instead of designing policy, why AI pilots plateau at “recommendation only,” and why architectural debt accelerates—not shrinks—under automation. This is not an implementation critique. It’s an architectural one. You’ll leave with:
    • A new mental model for HR systems that survives scale, regulation, and AI
    • A diagnostic checklist to surface hidden policy and configuration entropy
    • A reference architecture that separates intent, facts, execution, and explanation
    If AI is exposing cracks in your HR platform instead of creating leverage, this episode explains why—and what to do next. pasted 🔍 What We Cover 1. The Foundational Misunderstanding
    • Why hire-to-retire is not a process
    • HR systems as distributed decision engines, not linear workflows
    • The danger of forcing dynamic obligations into static, form-driven stages
    2. Configuration Entropy: When “Setup” Becomes Policy
    • How templates, stages, connectors, and email phrasing silently become law
    • Why standardization alone accelerates hidden divergence
    • The three places policy hides:
      • Presentation (emails, labels, templates)
      • Flow structure (stages, approvals, branches)
      • Integration logic (filters, retries, mappings)
    3. Why AI Pilots Fail in HR
    • The intent extraction problem
    • Why models infer chaos when policy is implicit
    • Why copilots plateau at summaries instead of decisions
    • Why explainability collapses when intent isn’t first-class
    4. Platform Archetypes (Failure by Design, Not by Mistake)
    • Transactional cores with adaptive debt
    • Process rigor mistaken for intelligence
    • Global compliance creating local entropy
    • Identity platforms becoming shadow systems of record
    • Integration glue evolving into the operating model
    5. The Mental Model Shift That Actually Works From lifecycle stages → to:
    • Capability provisioning
    • Obligation tracking
    • Identity orchestration
    Why systems can enforce contracts, not stories. 6. The HR Entropy Diagnostic (Run This Tomorrow)
    • Where does policy actually live today?
    • Can you explain why a decision happened—with citations?
    • Where do HR, identity, and compliance disagree—and who wins?
    • What’s the half-life of exceptions in your environment?
    7. Reference Architecture That Survives AI Four layers, one job each:
    1. Policy layer – versioned, testable intent
    2. Event layer – immutable facts, not stages
    3. Execution layer – subscribers, not rule authors
    4. AI reasoning layer – explanation first, always cited
    8. A 90-Day Architectural Debt Paydown Plan
    • Pull policy out of workflows
    • Make facts explicit and immutable
    • Compile identity instead of hand-building it
    • Require citations, TTLs, and loud failures by default
    🎯 Key Takeaway Lifecycles are narratives.
    Systems require contracts. Until policy is explicit, versioned, and machine-queryable, AI will amplify drift—not fix it. 📣 Call to Action If your HR team spends more time debugging integrations than designing policy, this episode is for you. Subscribe for the next deep dive on authorization compilers and policy-driven identity, and share this episode with the person still “fixing” flows instead of moving intent out of them.

    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
    1 ora e 12 min
  • The 10 Architectural Mandates That Stop Copilot Chaos

    The 10 Architectural Mandates That Stop Copilot Chaos
    Jan 6 2026
    The 10 Architectural Mandates That Stop Copilot Chaos Most organizations treat Copilot like a helpful feature. That assumption is the root cause of nearly every Copilot incident. In reality, Copilot is a distributed decision engine riding Microsoft Graph—compiling intent, permissions, and ambiguity into real actions. When boundaries aren’t encoded, ambiguity becomes policy. In this episode, we move past theory and features and lay out ten enforceable architectural mandates that turn Copilot from a chaos amplifier into a governed control plane. This is a masterclass for architects, security leaders, and operators who own the blast radius when Copilot goes wrong. What This Episode Delivers
    • A clear explanation of why Copilot failures are architectural, not model errors
    • The single misunderstanding that creates data leakage, hallucinated authority, and irreversible automation
    • A practical control pattern you can implement immediately
    • Ten mandates that convert intent into enforceable design
    • A red-flag test to identify Copilot chaos before the incident ticket arrives
    This is not a tour of Copilot features. It’s a system-level blueprint for controlling them. The Core Insight Copilot is not a colleague or assistant. It is a control plane component.
    It does not ask clarifying questions.
    It evaluates the state you designed—and executes inside it. If intent is not encoded in scopes, identities, gates, and refusals, Copilot will faithfully compile ambiguity into behavior. Confidently. At scale. The 10 Architectural Mandates (High-Level)
    1. Define the System, Not the Feature – Name the control plane you’re operating.
    2. Boundaries First – Constrain Graph scope before writing prompts.
    3. Structured Output or Nothing – Prose drafts are safe; actions require schemas.
    4. Separate Reasoning from Execution – Reason → Plan → Gate → Execute. Always.
    5. Authority Gating – No citations, no answers. Truth or silence.
    6. Explicit State – Session contracts and visible context ledgers only.
    7. Observability, Budgets, and Drift – Cost is a security signal.
    8. Identity & Least Privilege – Agents are roles, not people.
    9. Teams & Outlook Controls – Conversation is a high-risk edge.
    10. Power Automate Guardrails – Where hallucinations become incidents.
    Each mandate is tied directly to real failure modes already showing up in enterprises: silent data leakage, confidently wrong decisions, unauthorized automation, false trust from “memory,” and runaway cost. Who This Episode Is For
    • Enterprise architects and platform owners
    • Security, identity, and governance teams
    • Copilot Studio and Power Automate builders
    • Leaders accountable for compliance, audit, and incident response
    If you are responsible for outcomes—not demos—this episode is for you. Key Takeaway Copilot does not create chaos.
    Unencoded intent does. Acceleration is easy.
    Control requires architecture. Encode the boundaries.
    Gate authority.
    Separate thinking from doing.
    Instrument everything. That’s how you stop Copilot chaos—without slowing the business.

    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
    1 ora e 30 min
  • The Dynamics AI Agent Lie: It's Not Acceleration, It's Architectural Erosion

    The Dynamics AI Agent Lie: It's Not Acceleration, It's Architectural Erosion
    Jan 5 2026
    The Dynamics AI Agent Lie: It’s Not Acceleration, It’s Architectural Erosion This episode isn’t about whether Dynamics 365 Copilot works—it does. It’s about what it quietly dissolves. We explore how agentic assistance accelerates throughput while eroding the architectural joints that carry governance, accountability, and intent. Not through failures or breaches, but through drift: controls still exist, dashboards stay green, and meaning slips away. What We Cover
    • Acceleration vs. Erosion: Why speed isn’t neutral—and how increased throughput stresses the places where policy meets behavior.
    • Agents as Control-Plane Participants: Copilot isn’t an in-app helper; it’s a distributed decision engine spanning Dynamics, Graph, Power Automate, Outlook, and Teams.
    • Mediation Replaces Validation: How summaries, confidence bands, and narratives reframe what humans actually review.
    • Composite Identity & RBAC by Composition: Why least privilege passes reviews while effective authority expands across orchestrated pathways.
    • Non-Determinism on Deterministic Rails: How probabilistic planning breaks regression testing and replay.
    • Blast Radius Growth: Helpful actions propagate across surfaces, widening incident scope.
    • Audit Without Causality: You can see what happened, not why—because the decision trace lives outside your logs.
    The Four Scenarios That Quietly Reshape Control
    1. Invoice Approval — Validation becomes mediation; approval quality tracks narrative quality, not signal quality.
    2. Credit Hold Release — Deliberate exceptions become suggestible defaults; seasonality and partial histories collapse into a click.
    3. Procurement Vendor Selection — “Neutral” recommendations privilege data density and integration, calcifying supplier mix.
    4. Customer Service Resolution — Ambiguous authority by design; benevolence defaults leak value under queue pressure.
    The Mechanics Behind the Drift
    • MCP & Orchestration: View models expose affordances; planners compose legitimate actions into emergent pathways.
    • Human-like Tooling (Server-Side): Robust navigation without a client increases confidence—and hides discarded branches.
    • Deterministic Cores, Probabilistic Paths: The function is stable; the path to it isn’t.
    Controls That Fray—and What to Do Instead
    • Why DLP, Conditional Access, Least Privilege, ALM, and SoD struggle against composition and synthesis.
    • What survives: intent enforced as design—decision traces, step-up on sensitive tool invocation, ALM parity for prompts/tool maps/models, and SoD across observe-recommend-execute.
    The One Test to Run Next Week Pick one real, dollar-impacting Copilot-influenced decision and score it on five flags: Composite Identity Unknown, Lineage Absent, Non-Determinism, Unbounded Blast Radius, Accountability Diffused. Two or more flags isn’t a bad record—it’s your baseline. Executive Takeaway Speed improves medians while widening tails. The debt shows up as variance you don’t price, blast radius you don’t bound, and explainability gaps you don’t track. Pay a little friction now—gates, traces, step-ups—or pay later in archaeology. Remember This
    • If intent isn’t enforceable in code, it won’t hold in production.
    • If you can’t reproduce a decision, you can’t defend it.
    • If your logs don’t capture causality, you don’t have accountability.
    • Exceptions are entropy; budget them.
    • Paper controls can’t govern compiled behavior.
    Resources & Checklist: Link in the notes.
    Subscribe for more calm, clinical breakdowns of enterprise AI—without hype.

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