AI Tools Academy
Microsoft Copilot 0/20

Phase 2 · Microsoft Copilot · Level 3 · Power User

The natural handoff from Copilot to Power Automate

Concept · 10 minLast checked against the live product: 14 July 2026

30-second recall from earlier lessons
An AI assistant gives you a confident, well-written answer with a specific statistic and a link to a source. You need the figure for a board paper. What's the wisest next step?
A colleague pastes a signed client contract into their free, personal ChatGPT account to get a quick summary. What's the core problem?

By the end, you'll be able to…

  • Tell the difference between a job for Copilot's judgement and a job for a Power Automate flow
  • Recognise the trigger-and-action shape of work that should be automated, not prompted each time
  • Use Copilot inside Power Automate to draft a flow from a plain-English description

Why it matters

Copilot is brilliant at one-off, judgement-heavy work like drafting, summarising and deciding tone. But some tasks aren't judgement calls at all; they're the same mechanical steps every time, triggered by the same event. Prompting Copilot to do those by hand, over and over, is a waste. That's where Power Automate takes over. This lesson shows you the seam between the two, so you stop hand-cranking work a flow should be doing on its own, and it sets up the whole of Phase 5.

Two different kinds of work

By now you can get Copilot to do impressive things: draft a reply, summarise a thread, analyse a sheet, answer from an agent. All of these share a quality: they involve judgement. You're bringing a task that's a bit different each time and asking for language, structure or analysis in return. Copilot earns its keep exactly where the work needs a human-like read of the situation.

But look closely at your week and you'll find a second kind of work hiding in it: tasks that are the same every single time, kicked off by the same event. When a form is submitted, save the attachment to a folder and post a note in the team channel. When an email lands from a particular sender, log it in a list. When a file is added to a library, start an approval. There's no judgement here, no tone to get right, no analysis to do. There's just a trigger and a fixed set of actions that follow it, identically, forever.

Asking Copilot to do that second kind of work conversationally, saying "here's another form, please save the attachment and post a note" every time it happens, is a mistake of the tool, not the effort. It's mechanical, repeatable work being done by hand. That is precisely what Power Automate exists to take off your plate.

The seam: judgement versus repeatable steps

Here's the clean way to tell which side of the seam a task falls on. Ask two questions:

  • Is it triggered by a specific event? ("Whenever X happens…") If yes, it leans towards automation.
  • Are the steps the same every time, with no real judgement in them? If yes, it leans towards automation.

If a task is both event-triggered and mechanically identical each time, it belongs in a flow, a Power Automate automation with a trigger (the event that starts it) and one or more actions (the steps that follow), connected to your apps through connectors. If either answer is "no, it's different each time, or it needs a judgement call," keep it with Copilot.

Most real workflows are a blend, and that's the important insight: the two tools hand off to each other. A common shape is Copilot does the thinking part, a flow does the plumbing. Copilot drafts the customer reply (judgement); a flow then logs that a reply was sent, files the thread and updates a tracker (mechanics). You do the bit that needs a brain; the flow does the bit that just needs doing, reliably, at 3am, without you.

The choice is now three-way: flow, agent or Cowork

That seam used to have just two sides: judgement stayed with you and Copilot, mechanics went to a flow. It's worth updating the picture, because the "work I keep doing by hand" pile now has three possible homes, not two, and picking the right one is the real skill.

  • A flow (Power Automate) is for the mechanical, event-triggered work above: same trigger, same steps, no judgement. Build it, check it, and it runs unattended forever.
  • An agent (the Agent Builder or Copilot Studio agents from earlier in this level) packages judgement you use repeatedly so you, or other people, can invoke it on demand: "answer questions from these documents," or "answer and then log a ticket." You build it once and it serves the same recurring need again and again.
  • Copilot Cowork is for the big, multi-step, judgement-heavy job you'd rather hand over whole and collect finished: "pull these sources together, work through them, and give me back a drafted deliverable." It runs in a secure cloud, so the work continues with your laptop closed, and (as the agentic lesson covered) an admin enables it and it's billed by consumption. Phase 6 treats it as a genuine coworker you brief and then review; see The AI coworker.

So the three-way test is: is the work mechanical and event-triggered (a flow), a repeatable judgement service others could reuse (an agent), or a one-off but large piece of thinking work you want done end to end (Cowork)? That richer set of choices only sharpens this lesson's core instinct: stop hand-cranking work that a better-suited tool should be carrying for you.

You don't have to learn a new language to start

The reason Power Automate belongs in this lesson, right after Copilot, is that Copilot now builds flows for you too. In Power Automate there's a "Create your automation with Copilot" box: you describe, in plain English, what you want to happen, and Copilot generates the flow's structure, a suggested trigger and one or more actions, and even helps set up the connections. You don't need to know in advance which of Power Automate's flow types to use; your description determines it.

So the skill you've built all phase, describing what you want clearly, transfers directly. Here's a worked example. Suppose Fernway wants every new customer complaint email logged automatically. The plain-English description you'd type into Power Automate's Copilot:

Describe the flow you wantPower Automate
When a new email arrives in the shared complaints mailbox, add a row to the "Complaints Log" Excel table with the sender, subject, date received and a blank status column, then post a short message in the Support Teams channel saying a new complaint has been logged.

Why this works: It names the trigger ('when an email arrives') and the actions ('add a row', 'post a message') in one plain sentence, which is exactly the shape Power Automate's Copilot needs to draft a working flow, no flow-type jargon required.

Copilot drafts a flow with the mail trigger and the two actions, and prompts you to confirm the connections (the mailbox, the workbook, the channel). What you get is a draft to review, the same principle as everywhere else in this course. You check the trigger is the right mailbox, the columns map correctly, and the channel is the right one, then test it on a sample before trusting it. A flow that runs unattended is powerful precisely because it runs unattended, which is exactly why the first run deserves your full attention.

Notice the division of labour in that example: the flow handles the mechanical logging perfectly, but it deliberately leaves the reply, the judgement-heavy, customer-facing part, to a human using Copilot. That's the seam working as it should: automate the plumbing, keep the judgement.

More example prompts

Sort your week into judgement vs automationCopilot
Here are some recurring tasks from my week: [list them]. For each, help me decide whether it's a job for Copilot's judgement, a job for a Power Automate flow, or a blend. Assess each against two questions: is it triggered by a specific event, and are the steps the same every time with no real judgement? Recommend a home for each and explain the ones that surprised you.

Why this works: Handing Copilot the two diagnostic questions turns a vague 'what could I automate?' into a sorted list, so you can see at a glance which tasks belong in a flow and which need a person.

Describe a file-triggered flowPower Automate
When a new file is added to the [project documents] library, start an approval request to [the project lead], and once it's approved, move the file to the [Approved] folder and post a short note in the [project] Teams channel with the file name and who approved it. If it's rejected, notify me instead.

Why this works: Naming the trigger ('when a file is added') and the follow-on actions in plain English is exactly the shape Power Automate's Copilot needs to draft a working flow, no flow-type jargon required.

Design the Copilot-plus-flow handoffCopilot
Help me split this workflow into a Copilot part and a Power Automate part: [describe the workflow]. Tell me which single step really needs human-like judgement (and should stay with Copilot and a person), which steps are mechanical and repeatable (and belong in a flow), and exactly where the handoff happens and what a human should check at that point.

Why this works: Making the seam explicit, naming which step is judgement, which is plumbing, and what a human checks at the boundary, is the design skill that separates thoughtful automation from automating everything.

Try it now

Common mistakes

  • Hand-cranking automatable work. Doing the same trigger-and-actions task through Copilot conversationally every time it happens is effort wasted on something a flow would do unattended. If it's event-triggered and identical each run, automate it.
  • Automating a judgement call. The opposite error: pushing a task that really varies, like a nuanced reply or a sensitive decision, into a rigid flow. Flows are for the mechanical, unvarying part. Keep the judgement with Copilot and a person.
  • Trusting a new flow's first live run. A flow's strength is that it runs unattended, which is also its risk. Test it on a sample and watch the first real run before you let it loose; a wrong mapping repeats silently, every time, until someone notices.
  • Over-trusting a Copilot-drafted flow. Copilot draining the effort out of building a flow doesn't mean the flow is correct. It can pick a slightly wrong trigger, map the wrong column, or set up a connection you didn't intend. Read the drafted flow the way you'd read any Copilot draft: as a strong start to check, not a finished thing to trust.

Keeping current

Power Automate's Copilot and the new designer change often, and available triggers, actions and connectors grow constantly. Treat the specifics here as a July 2026 snapshot; Phase 5 goes far deeper. For current detail see Microsoft's Create your first cloud flow using Copilot and Copilot in Power Automate. Accurate as of 13 July 2026.