Video summary

Power Automate Beginner to Pro Tutorial [Full Course]

Main summary

Key takeaways

Technology

Summary of the tutorial (Power Automate Beginner → Pro)

Who the course is for / overall goal

  • The session is a “day of Power Automate” covering the full spectrum of what Power Automate can do:
    • Cloud flows (web-based automation)
    • Conditional logic, triggers, and approval workflows
    • Power Automate Desktop for legacy/desktop/RPA scenarios
    • Administration and environment management via solutions and lifecycle concepts

Foundations: Power Platform + Power Automate positioning

  • The speaker frames Power Automate as part of the Microsoft Power Platform, aimed at citizen developers (business users building their own automations).
  • Other tools in the Power Platform mentioned:
    • Power BI (analytics/reporting)
    • Power Apps (low-code apps)
    • Power Automate (automation)
    • Power Virtual Agents (chatbots)
  • Shared platform concepts:
    • Connectors (many shared across tools)
    • AI Builder
    • Dataverse for shared storage/data

What Power Automate is / key design concept

  • Purpose: reduce repetitive tasks by turning them into flows, freeing time for strategic work.
  • Supports end-to-end automation across modern apps and legacy apps.
  • Mentions 470+ connectors, including the ability to build custom connectors and use a connector library.

Cloud Flows (Cloud-based automation)

Cloud Flow vs Desktop Flow (main distinction)

  • Cloud flows
    • Best for modern applications with APIs
    • Built entirely in the web browser
    • Can trigger/orchestrate desktop flows (cloud acts as the organizer/scheduler)
  • Desktop flows
    • For legacy applications without APIs
    • Built using Power Automate Desktop (installed client)

Cloud Flow building blocks

  • Every cloud flow uses:
    • Trigger: starts the flow (Power Automate “listens/waits”)
    • Actions: what the flow does
    • Conditional logic (if/else style branching)

Templates: starting faster

  • Power Automate includes pre-built templates to get started quickly.
  • Demonstration flow built from a template:
    • Template: “Post to Microsoft Teams when an email arrives in Office 365 Outlook”
    • Behavior:
      • Trigger: email arrives
      • Action: post email body into a Teams channel/chat
    • Includes optional filtering like “emails with specific subject lines.”
  • Notes on templates and solutions:
    • Templates may create flows outside of solutions by default, but they can be added later.

Testing and execution monitoring in cloud flows

  • Flows have:
    • Test mode (manual vs automatic tests)
    • Execution history showing previous runs, parameters, and failures
  • Best practice mentioned:
    • Set multiple owners (not just one person) to reduce risk if someone is on vacation or fails.

Cloud Flow tutorial examples

Example 1: Template-based Teams notification

  • Build a flow using a template:
    • Trigger: new Outlook email arrives
    • Optional condition: subject line filter
    • Action: post to Teams channel
  • Testing:
    • Send an email with a matching subject
    • Confirm the Teams message appears

Example 2: Build from scratch using Microsoft Forms → Outlook (HTML email)

  • Use case:
    • A Microsoft Form collects registration details.
    • Addressed limitation: Forms don’t send much back automatically.
  • Flow:
    • Trigger: new Microsoft Forms response submitted
    • Action 1: get response details
    • Action 2: send email via Outlook
      • Email body supports HTML
      • Includes a Teams meeting link
      • Uses dynamic content (e.g., first name)
  • Testing:
    • Manually submit the form
    • Confirm an email is generated with dynamic fields and the Teams link

Example 3: SharePoint list-driven routing (and best practice: trigger conditions)

  • Use case:
    • A SharePoint list represents “virtual mentoring requests.”
    • Goal: notify only Power Automate requests; ignore others.
  • Less optimal approach shown first:
    • Trigger: when an item is created in SharePoint
    • Then use a Condition to decide whether to send email
    • Result:
      • The flow still runs for all requests; email is only suppressed when the condition fails.
  • Improved approach (best practice):
    • Use a trigger condition on the SharePoint trigger instead of branching after the trigger.
    • This prevents the flow from firing unless the requested topic matches.
  • Expression guidance:
    • Introduces Power Automate expression language
    • Uses a Compose action temporarily to craft an expression, then pastes it into the trigger condition
    • Emphasizes that trigger conditions must be prefixed with @

Approvals (human-in-the-loop control)

What approvals are

  • Approvals insert human interaction into automations:
    • A human can approve or reject before the flow proceeds.

Approval action types described

  • The tutorial mentions:
    • Start and wait for an approval (pause until approved/rejected)
    • Create an approval (flow continues; separate wait step later)
    • Wait for an approval
  • Approval “assigned behavior” described:
    • Approve/Reject everyone (all must respond)
    • First to approve / First to respond (first responder determines outcome)

Approval demo integration (SharePoint list)

  • Flow logic:
    • SharePoint trigger detects new “mentoring request” for Power Automate (using the earlier filtering approach)
    • Insert Start and wait for an approval in the middle
    • Approval details:
      • Title and details use dynamic content
      • Sent via Microsoft Teams approvals and can also appear in inbox
      • Requires listing individual email addresses (not AD groups)
    • After approval:
      • Condition checks approval outcome:
        • If approved → send email
        • If rejected → do nothing
  • Testing:
    • Insert a matching request into SharePoint
    • Approvals appear in Teams
    • Approving triggers the email step; flow completes only on the approval path

Power Automate Desktop (RPA / legacy automation)

Where Desktop fits

  • Desktop flows are for legacy apps where cloud automation can’t reliably connect via APIs.
  • Requirements:
    • Power Automate Desktop client installed
    • Dataverse present in the environment (metadata requirement)
    • Potential extra RPA licensing

Desktop flow editor concepts

  • Desktop flow creation uses a drag-and-drop style workflow.
  • UI highlights:
    • Actions/search bar (400+ actions)
    • Workspace to build the flow
    • Subflows to modularize large workflows
    • Tabs:
      • Variables
      • UI elements (capture UI selectors)
      • Images
  • Advanced capabilities mentioned:
    • Error handling
    • Call scripting (e.g., PowerShell/VBScript/Python)
    • Debugging, breakpoints, message boxes
    • Unattended vs attended execution
      • Unattended can run without interactive sign-in (may cost more)

Desktop tutorial example: “Contoso invoicing” legacy app automation

  • Problem:
    • A legacy invoicing application has no usable API.
    • Manual steps: open app → navigate to invoices → create invoice → fill fields → save.
  • Solution built:
    • Desktop flow runs the app and enters invoice details automatically.
  • How the flow was built:
    1. Run application action (launch legacy EXE)
    2. Use Desktop Recorder to capture UI clicks/typing:
      • Navigate to “Invoices”
      • Click “New record”
      • Fill fields: date/account/contact/amount/status
    3. Save and test:
      • Relaunches the app and creates the invoice
  • Next step: parameterize with variables:
    • Create input variables (amount, contact, account)
    • Create output variable to capture invoice id
    • Replace hardcoded UI values with variables
    • Use Get details of a UI element to read the invoice ID shown in the app
    • Use Set variable to map extracted invoice ID into the output variable

Variables in Desktop flows

  • Desktop variables described as:
    • Flow variables (internal to the flow)
    • Input/Output variables (user-defined interface)
  • Variables include:
    • internal name vs external name
    • optional default values
    • “sensitive” marking for credentials

Orchestrating Desktop from Cloud (hybrid integration)

Running a Desktop flow from a cloud flow

  • Demonstration creates an instant (manually triggered) cloud flow.
  • Cloud flow includes an action:
    • Run a flow built with Power Automate Desktop
  • To connect cloud to desktop runtime, one of two methods:
    1. Data gateway
    2. Direct-to-machine via machine settings in Power Automate Desktop
      • Requires enabling Open machine settings
      • Connects the environment/machine to the cloud service
      • Allows the cloud flow to select the desktop machine and run it

Execution modes and passing parameters

  • Desktop run mode options:
    • Attended (machine must be logged in)
    • Unattended (machine can run without a user session; more licensing)
  • Cloud execution passes desktop input variables:
    • amount, contact, account
  • Test result:
    • Cloud flow triggers desktop flow
    • Desktop app launches and enters invoice with values provided by the cloud execution

Administration: environments + solutions (lifecycle management)

  • Environments are described as containers for Power Platform assets (apps/automations).
  • Best practice emphasized:
    • Use Solutions to manage and migrate across environments (dev → test → prod)
  • Solutions:
    • package cloud flows and other components
    • can include existing items or new items
    • support publishing and exporting/migration via zip behavior

Main speakers / sources

  • Primary speaker: Devin Knight (President of Training at Pragmatic Works; Microsoft MVP; author/trainer)
  • Additional referenced contributors:
    • “Jonathan” (colleague assisting in chat and correcting a variable/insight during the demo; also referenced as co-teaching the RPA in a Day material with Devin)

Original video