Microsoft Copilot Expert
Building, integrating and governing enterprise agents on the Microsoft stack
About this course
An advanced course on building enterprise agents with Copilot Studio and extending Microsoft 365 Copilot: the platform architecture, declarative agents over real knowledge sources, custom agents when declarative is not enough, Graph connectors and the semantic index, and enterprise integration through connectors and gateways.
It closes on governance done properly for the Microsoft stack: identity, data controls, connector permissions, data loss prevention and application lifecycle management across environments.
Six mentored modules, most with a lab, each with a practice brief, plus a pre-assessment, a post-assessment and a group capstone.
What you’ll be able to do
- Explain Copilot Studio's tenant and environment topology, its Dataverse dependency, and what each licensing tier actually changes for a design
- Build declarative agents over real knowledge sources, with topic modelling, slot filling, disambiguation, fallback and escalation designed rather than defaulted
- Decide between a declarative and a custom agent on orchestration need, token budget and latency, and justify it
- Extend Microsoft 365 Copilot: Graph connectors, schema design, ranking and relevance testing, message extensions and Teams agents
- Integrate line-of-business systems through custom connectors with authentication, error handling, throttling and circuit breaking
- Instrument agents: topic analytics, transcripts, Application Insights and alerting
- Govern the platform with Microsoft-specific controls: Entra ID identity and consent, Purview data controls, connector and DLP policies, and environment-based ALM
Before you start
What this course assumes you can already do.
- Basic enterprise architecture experience, and familiarity with REST APIs and JSON.
- Entra ID fundamentals: users, groups, app registrations, consent.
- CI/CD and application lifecycle management principles.
- Data governance and compliance awareness, including data residency concepts.
- Conversational AI fundamentals, and some exposure to Azure OpenAI Service.
- Familiarity with Microsoft Teams administration.
- Your own Microsoft 365 tenant with the relevant Copilot licences and Azure services for the labs.
The curriculum
Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.
Recaps and reference material are included in the LMS.
PART 1Platform and declarative agents
01Architecture and Platform
Understand the platform well enough that your design decisions account for tenant topology, the Dataverse dependency, licensing limits and which action type belongs where — before you build anything on it.
- Copilot Studio architecture deep-diveConcept
- Agents, knowledge sources and connectorsConcept
- Actions framework: flows, prompts, REST and AI BuilderConcept
- Lab: environment setup and first connectionsHands-on
Design against the platform limits, not around them
Take one agent you would genuinely like to build. Write the platform design for it: which environment, what the Dataverse dependency implies, which licensing tier the design requires, and which action type each capability needs.
Knowledge checkpoint with explained answers
02Building Declarative Agents
Design a declarative agent that behaves predictably at the edges: knows what it does not know, asks for what it needs, and escalates rather than improvising.
- Agent design patterns and topic modellingConcept
- Multichannel deploymentConcept
- Lab: build an HR self-service agentHands-on
Build an agent that behaves at the edges
Build a declarative agent over a knowledge source, then test it with the inputs that break agents: ambiguous questions, missing information, out-of-scope requests, and questions whose answer is genuinely "ask a human".
Knowledge checkpoint with explained answers
PART 2Custom agents and Microsoft 365
03Custom Agents
Know exactly when declarative stops being enough, and be able to build and defend the custom alternative on orchestration need, token budget and latency.
- When to go custom: the decision frameworkConcept
- Azure OpenAI and Bot Framework integrationConcept
- Lab: custom plugin with an OpenAPI specificationHands-on
Make the declarative-or-custom decision on evidence
Take one requirement that pushes past declarative. Build the declarative version until it fails, record exactly how it failed, and only then design the custom alternative.
Knowledge checkpoint with explained answers
04Microsoft 365 Copilot
Extend Microsoft 365 Copilot with your organisation's own content, and test relevance properly instead of hoping the ranking behaves.
- The Microsoft 365 Copilot extensibility modelConcept
- Graph connectors and the semantic indexHands-on
- Lab: publish an agent to Microsoft 365 CopilotHands-on
Ingest external content and test relevance properly
Ingest an external content set through a Graph connector, design its schema, then find out whether the right things come back — with a gold set, not by trying a few queries.
Knowledge checkpoint with explained answers
PART 3Enterprise integration and governance
05Enterprise Integration Patterns
Connect an agent to real line-of-business systems without becoming the reason they fall over, and instrument it well enough to debug from the outside.
- Enterprise connector patternsConcept
- Scalability, resilience and observabilityHands-on
- Lab: integration with an enterprise APIHands-on
Integrate with a system that misbehaves
Connect an agent to a mocked line-of-business API through a custom connector with authentication, then make the API behave badly: slow, throttled, intermittently failing, returning malformed data.
Knowledge checkpoint with explained answers
06Governance, Adaptation and Responsible AI
Govern the Microsoft AI stack with the controls it actually has: identity and consent in Entra ID, data controls in Purview, connector and data-loss-prevention policies, environment-based lifecycle management, and adoption measurement that suits an agent platform rather than a code assistant.
- Identity, consent and access governance in Entra IDHands-on
- Data controls: sensitivity, oversharing and PurviewConcept
- Connector governance and data loss prevention policyHands-on
- Application lifecycle management across environmentsHands-on
- Measuring adoption of an agent platformConcept
- Responsible AI for enterprise agentsConcept
- Questions and open discussionConcept
Write the governance position for an agent platform
Produce the governance package for one agent going to production in a tenant you know.
Knowledge checkpoint with explained answers
A multi-source knowledge agent with a governance position
A capstone that deliberately forces integration across all six modules: a technical deliverable, a governance or process artefact, and a stakeholder presentation. You build an agent drawing on three distinct enterprise sources — an intranet site, an external documentation site ingested through a Graph connector, and a structured FAQ dataset — with a custom orchestration layer for complex queries, content moderation enforced, and a centre-of-excellence governance report covering usage analytics, personal-data handling and compliance posture.
Platform and knowledge design — Decide the topology and the sources before building.
The declarative agent — Build it and test it where agents break.
Graph connector and custom orchestration — The third source, and the orchestration the simple version could not do.
Integration and resilience — Connected, instrumented, and tested against a misbehaving dependency.
Centre-of-excellence governance report — The process artefact, with Microsoft controls throughout.
Stakeholder presentation — Present to a room including someone whose job is to say no.
Next course
Tell us about yourself or your team and we’ll let you know how and when you can take this course.