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

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

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

De : Mirko Peters (Microsoft 365 consultant and trainer)
Écouter gratuitement

3 mois pour 0,99 €/mois

Après 3 mois, 9.95 €/mois. Offre soumise à conditions.

À propos de ce contenu audio

 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 Politique et gouvernement
Les membres Amazon Prime bénéficient automatiquement de 2 livres audio offerts chez Audible.

Vous êtes membre Amazon Prime ?

Bénéficiez automatiquement de 2 livres audio offerts.
Bonne écoute !
    Épisodes
    • Beyond ITSM: The ServiceNow and Microsoft Power Play

      Beyond ITSM: The ServiceNow and Microsoft Power Play
      Jan 26 2026
      Most organizations think ServiceNow is a ticketing tool and Microsoft is a productivity suite. Both assumptions are wrong—and they’re why enterprise work still breaks under pressure. In this episode, we unpack why ITSM was only the entry point, why tickets don’t control outcomes, and how real enterprises need an operating layer that turns human intent into governed execution. This is a deep dive into workflows, orchestration, and why Microsoft and ServiceNow aren’t competitors—they’re two halves of a necessary system. 🔍 Opening Thesis Ticketing was never the destination—it was the doorway.
      Microsoft is where intent is created: chats, emails, meetings, documents.
      ServiceNow is where intent must become execution: routing, approvals, state, and evidence.
      Workflows don’t fail in theory—they fail at org-chart boundaries. 🧠 Key Ideas & Mental Models 1. Digitally Rich, Operationally Fragmented Enterprises have plenty of tools but no shared operating layer. Work moves through inboxes, chats, portals, tickets, and spreadsheets—none of which own end-to-end state. The result is visibility everywhere and progress nowhere. Insight: The real problem isn’t tool sprawl. It’s workflow fragmentation. 2. Tickets Track Pain—Workflows Control Outcomes Tickets log problems. They don’t enforce solutions.
      When tickets become the operating model, organizations optimize for logging instead of execution, and humans improvise the real process in side channels. Insight: Enterprises aren’t punished for missing visibility. They’re punished for missing execution. 3. Systems of Record vs Systems of Action
      • Systems of record (ERP, HRIS) preserve truth
      • Systems of action route work, enforce sequence, and capture evidence
      Trying to make one replace the other produces friction, bypasses, and audit pain. Insight: Documents aren’t state. Chat isn’t governance. A mailbox is not an audit trail. 4. The Microsoft / ServiceNow Split (in Plain Terms)
      • Microsoft owns engagement: where humans work and express intent
      • ServiceNow owns execution: where work becomes a governed state machine
      One captures pressure. The other enforces outcomes. Insight: One experience, two authorities. 5. Events → Workflows → Decisions → Outcomes Most enterprises drown in events and improvise the rest.
      A real operating layer converts events into executable workflows, enforces decisions with identity and policy, and produces defensible outcomes. Insight: Read can be fast and forgiving. Write must be governed. 🧩 Real-World Scenarios Covered
      • Employee onboarding without email chains or orphaned access
      • Security incident response: Teams for war rooms, ServiceNow for control
      • Finance approvals without policy erosion at quarter-end
      • Major incidents & emergency change without turning chat into a control plane
      Across all cases: collaboration stays human, execution stays deterministic. 🤖 AI in the Operating Layer Copilot and Now Assist are not rivals—they have different jurisdictions:
      • Copilot understands human context
      • Now Assist understands operational state
      AI proposes. Workflows enforce. Humans authorize. Insight: AI without workflows creates noise. AI inside workflows creates outcomes. ⚠️ Common Failure Modes to Avoid
      • Workflow entropy (“temporary exceptions” that become policy)
      • Shadow automation outside governance
      • Permission drift through overscoped connectors and agents
      Insight: Entropy always wins where enforcement is optional. 🚀 The Operating Model That Scales
      • Microsoft = intent capture and collaboration
      • ServiceNow = execution, routing, approvals, and evidence
      • Start read-heavy, move to governed writes, then controlled agentic execution
      Insight: Enterprises don’t need smarter chat. They need execution throughput. 🎯 Final Takeaway The real power play isn’t Copilot versus Now Assist.
      It’s building an operating layer where human intent reliably becomes governed execution—every time, under pressure, with proof.

      Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.

      If this clashes with how you’ve seen it play out, I’m always curious. I use LinkedIn for the back-and-forth.
      Afficher plus Afficher moins
      57 min
    • The Future of Enterprise Connectivity: Unlocking Innovation with Logic Apps and Copilot Studio

      The Future of Enterprise Connectivity: Unlocking Innovation with Logic Apps and Copilot Studio
      Jan 25 2026
      Episode OverviewMost enterprises think connectivity is a plumbing problem. It isn’t. It’s an intent problem. In this episode, we break down why integrations keep failing even when APIs and connectors exist—and how a new architecture model built on Copilot Studio, Logic Apps, and MCP changes what’s possible. This isn’t a product demo. It’s a set of executive mental models for building enterprise AI that scales without collapsing under governance, audit, and operational reality. 🔑 Core Themes & Takeaways 1. Integration Isn’t the Problem—Intent IsEnterprises already have connectivity: APIs, ETL, connectors, platformsFailures happen when intent is lost at handoffs between systems and teamsHumans become message buses; tickets become state machinesAutomation breaks down because systems preserve transactions, not decisionsKey insight: You don’t need more integration—you need coordination with traceability. 2. Why AI Makes This Better (and Worse)AI changes where decisions are made, not just how workflows runBolting chat onto broken processes creates non-deterministic failuresWithout guardrails, AI guesses—and enterprises pay in incidents and auditsKey insight: AI is a distributed decision engine, not a smarter form. 3. MCP Explained in Plain TermsModel Context Protocol (MCP) is not a connector or API replacementIt’s a contract between reasoning (AI) and execution (enterprise systems)Models choose from approved, well-defined tools instead of inventing pathsMCP makes AI less creative where creativity is dangerousKey insight: MCP doesn’t make models smarter—it makes them safer. 4. Logic Apps: The Execution SpineLogic Apps is a deterministic, auditable workflow runtimeHandles retries, sequencing, compensation, and observabilityConnectors become raw material, not governanceSingle-tenant and hybrid models enable real enterprise controlKey insight: In the AI era, execution must be boring—and provable. 5. Copilot Studio: The Intent InterfaceCopilot Studio excels at conversation, interpretation, and tool selectionIt should not directly execute enterprise writesIts job is to extract intent and choose the right governed actionKey insight: Copilot decides what should happen—Logic Apps ensures it happens safely. 6. The Two-Plane Architecture Model Reasoning Plane:Copilot StudioProbabilistic, conversational, adaptiveExecution Plane:Logic AppsDeterministic, auditable, policy-enforcedMCP forms the seam between the two. Key insight: Blending reasoning and execution creates conditional chaos. 🧩 Real Enterprise Scenarios CoveredHR Onboarding: From day-one access to auditable entitlementsInvoice Processing: Exception handling without email archaeologyIT Service Automation: Tier deflection with policy-safe executionSAP & System Sync: Transactional integrity without finance falloutCompliance & Audits: Evidence as a system output, not a scrambleAcross all scenarios: fewer handoffs, fewer exceptions, stronger controls. 🛡️ Governance That Enables SpeedGovernance is enforced through tool design, not policy decksNarrow, task-focused tools prevent drift and guessingManaged identity, private networking, environment isolation by defaultRun history becomes the source of truthKey insight: Control isn’t what you intend—it’s what the architecture allows. 🧠 Operating Model for ScaleBuild governed tools once, reuse everywhereCentral catalog for discovery and ownershipClear separation of roles: agent designers, workflow owners, operatorsWorkflows treated as production assets, not low-code experimentsKey insight: The ROI comes from reuse, not smarter prompts. ✅ Executive Checklist: Avoiding FailureDon’t expose generic “do everything” toolsDon’t let AI write directly to systems of recordDon’t skip networking, identity, or discoverabilityDon’t confuse pilots with operating modelsStart small. Prove traceability. Scale by reuse. 🔚 Final Thought The future of enterprise connectivity isn’t smarter chat—it’s governed execution. Copilot Studio turns intent into decisions. Logic Apps turns decisions into controlled, auditable action. Get the architecture right, and AI scales. Get it wrong, and entropy wins.Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-modern-work-security-and-productivity-with-microsoft-365--6704921/support.If this clashes with how you’ve seen it play out, I’m always curious. I use LinkedIn for the back-and-forth.
      Afficher plus Afficher moins
      58 min
    • From Tables to Strategy: What Smart Dataverse Models Really Mean for the Future of Business Apps

      From Tables to Strategy: What Smart Dataverse Models Really Mean for the Future of Business Apps
      Jan 24 2026
      This episode was inspired by Bülent Altinsoy Microsoft MVP, who delivered a four-hour Dataverse deep-dive workshop at M365Con—staying firmly in the mechanics: tables, relationships, security, and solutions. The parts teams usually rush through to get an app on screen. This conversation sits above that. Most Power Platform failures aren’t about low-code limitations. They happen because teams treat data as a temporary inconvenience—something to fix after the demo. Dataverse isn’t a magic database. It’s Microsoft offering a way to model reality with enough discipline that automation and AI can survive contact with production. This episode isn’t about features.It’s about why the model underneath your apps becomes strategy, whether you intended it or not. 1. Why “Low-Code Data” Keeps Failing in Production Low-code doesn’t fail because makers lack governance knowledge. It fails because the first data model is often a lie everyone agrees to—temporarily—to ship faster. Speed-first delivery creates meaning debt:Overloaded tablesGeneric columns like Status, Type, or OtherLookups added for dropdowns, not for shared understandingEverything works—until real production begins: scale, audits, integrations, edge cases, and time. Scaling doesn’t just multiply transactions; it multiplies contradictions. When meaning isn’t encoded, every downstream consumer invents it. That’s how “it works” quietly turns into “it’s unpredictable.” 2. Dataverse Is Not a Database — It’s a Business Semantics Engine Databases store facts. Dataverse stores facts plus meaning: relationships, ownership, security, metadata, and behavior that travel across apps, automation, and AI. Treating Dataverse like storage strips out its value. When intent isn’t compiled into structure, every app, flow, report, and agent interprets reality differently. Dataverse behaves more like a compiler than a table store.You write intent in structure—and Dataverse enforces consistent behavior everywhere. Weak models don’t break immediately.They scale mistakes quietly. 3. Why Data Modeling Is a Leadership Topic Data models outlive apps. Screens change. Flows get rewritten. But the model becomes sediment—accumulated assumptions the organization builds on, even when nobody owns them. Governance doesn’t emerge from policy decks. It emerges from structure:OwnershipSecurity scopesRelationshipsConstraintsMetadataIf leaders don’t define the core nouns of the business, Dataverse will faithfully scale organizational ambiguity instead. Good models scale clarity. Bad models scale meetings. 4. From Tables to Business Concepts A table is not storage. It’s a declaration. Creating a table says: this thing exists, has a lifecycle, has rules, and matters over time. Hiding concepts inside text fields or choice values says the opposite. Screen-driven modeling always collapses.UI is volatile. Nouns are durable. Tables are nouns.Processes are verbs. When teams store process steps as columns, every process change becomes a breaking schema change. Modeling nouns cleanly—and processes as related entities—lets systems evolve without rewriting history. 5. Relationships: How the Organization Actually Works Relationships aren’t navigation links. They encode policy. One-to-many defines structure.Many-to-many defines meaning when the relationship itself matters. Relationship behavior—parental, referential, restrictive—is not technical detail. It decides whether evidence survives deletions, whether audits pass, and whether context is reliable. Relationships create context.Context makes reporting sane, integrations stable, and AI coherent. 6. Solutions and Environments: Delivery Is Architecture Dataverse treats delivery as part of meaning. Environments aren’t convenience—they are boundaries where different versions of reality exist. Solutions don’t move data; they move definitions. Live development in production doesn’t create speed. It creates drift. Managed solutions trade convenience for determinism—and determinism is what protects meaning over time. 7. Scenario: SharePoint → Dataverse SharePoint works—until the data stops being “just a list.” Flat thinking collapses under:Relational complexityIntegrity gapsScale thresholdsGovernance ambiguityDataverse isn’t better because it’s more expensive.It’s better because it’s opinionated about correctness. Migration isn’t about moving data.It’s about admitting the system needs to be right—not just convenient. 8. Audit & Compliance: Governance by Design Audits don’t break systems—they reveal them. Dataverse governance is structural:Role-based securityOwnership on every rowScope-defined accessColumn-level securityAmbiguity forces manual controls. Manual controls create exceptions. Exceptions generate risk. Dataverse removes excuses by making access inspectable and enforceable. 9. The AI Moment: Context Retrieval at Scale AI doesn’t invent meaning. It ...
      Afficher plus Afficher moins
      51 min
    Aucun commentaire pour le moment