Power Automate Masterclass for Beginners: 2026 Companion Update Guide

The original 2021 session established a highly effective foundational understanding of Microsoft Power Automate. It focused heavily on the core mechanics of navigating the portal, constructing automated and scheduled logic, deploying flow controls, and managing workflow execution. Since that initial demonstration, the Power Platform has undergone a massive architectural and interface paradigm shift. The transition from manual logical construction to AI-assisted orchestration has fundamentally altered how cloud flows are developed today.

The classic drag-and-drop designer, familiar to those who watched the original masterclass, has been completely replaced by an AI-first, React-based New Designer. Microsoft Copilot is now deeply embedded within the authoring experience across the entire platform. This integration transforms natural language prompts into complex JSON flow definitions and utilizes advanced AI skill inferencing to streamline development. Furthermore, error resolution has evolved from manually parsing hexadecimal codes to interacting directly with specialized, natural-language debugging agents.

This comprehensive companion guide bridges the operational gap between the original session's demonstrations and the current state of the platform. It provides an exhaustive, step-by-step technical manual on how to construct the exact same scenarios demonstrated in the session using the modern March 2026 toolset. The following sections are anchored strictly to the six core demonstrations provided in the original video, updating every click, menu path, and architectural concept for the modern cloud environment.

What's Changed Since This Session

The landscape of Power Automate has been heavily optimized for developer velocity, resiliency, and AI integration. Microsoft has streamlined the user experience to reduce friction while simultaneously exposing deeper technical controls for advanced users. The following table summarizes the foundational shifts between the original 2021 session and the March 2026 environment.

How to Build This Today

The following sections provide exhaustive instructions on replicating the exact scenarios demonstrated in the original session. They utilize the current March 2026 feature set, terminology, and best practices.

1. Navigating the Environment and the Visual Flow Builder

The original session demonstrated navigating to the Power Automate portal and exploring the basic building blocks of a workflow. Today, the underlying URL remains the same, but the architecture and navigation hierarchy have been modernized to support widespread AI integration. The layout is optimized to handle complex, enterprise-scale workflows without overwhelming the browser memory.

Recapping the Demonstration:

The speaker demonstrated accessing the portal, browsing the left-hand navigation menu for templates, and entering the flow designer canvas to initiate a blank workflow. The focus was on identifying triggers and actions within the classic, single-column interface.

The March 2026 Build Process: The initiation of a workflow begins at the centralized maker portal. Authentication relies entirely on Microsoft Entra ID, ensuring secure access to your specific tenant and environment routing.

1. Access the Portal: Developers must navigate to the primary endpoint at make.powerautomate.com.
2. Navigate the Left Pane: Upon login, the left navigation pane presents several options: Home, Create, Templates, Learn, My flows, and Solutions.In 2026, additional AI-centric hubs exist. These include the AI Hub (for accessing AI Builder models and generative prompts) and Process mining (for analyzing business bottlenecks).
3. Initiate a New Flow: To begin, makers navigate to the left menu and select My flows > New flow.From here, the platform prompts the selection of a flow type. The primary cloud options remain Automated, Instant, or Scheduled.
4. Enter the New Designer Canvas: Once a flow type is selected and named, the New Designer launches. Unlike the classic interface, the 2026 designer strictly separates the visual representation of the workflow from its technical configuration.

The workspace is now divided into highly specific zones to improve developer focus and handle complex logic trees.

• The Canvas: The center screen displays the flow structure using atomic action cards and container actions. These are connected by blue dashed drop zones, indicating where new actions can be inserted.
• Configuration Pane: Selecting any action card opens a dedicated pane on the left side of the screen. This pane contains comprehensive tabs for Parameters (inputs), Settings (timeouts, run-after configurations), Code View (raw JSON definition), and Testing (static results mocking).
• Copilot Pane: A persistent panel on the right side of the screen allows developers to alter the flow via conversational prompts.

Architecture of the 2026 Power Automate New Designer

The modern authoring experience segregates the workspace into three distinct zones; the central visual canvas, the detailed configuration pane on the left, and the conversational Copilot pane on the right.

The new interface drastically improves navigation for complex flows. The command bar at the top houses essential tools like the Flow checker, Undo/Redo, and Save. Furthermore, specific tools have been added to assist with visual scaling.

2. Building an Automated Cloud Flow (SharePoint / Email)

The second session module showcased how to automate actions based on external events. Specifically, it demonstrated executing logic when an email arrives or a SharePoint item changes. Automated cloud flows run entirely in the background, continuously listening for webhooks or polling specific APIs.

Recapping the Demonstration:

The speaker built a straightforward flow that triggered automatically when a new item was added to a SharePoint list. This trigger subsequently passed dynamic data to an Outlook action, which sent an automated email notification to a designated user.

The March 2026 Build Process: The integration between Power Automate and SharePoint remains a cornerstone of the platform, with over 100 dedicated templates available. However, constructing this flow from scratch now leverages the segmented configuration pane.

1. Select the Trigger: Navigate to the left menu and click Create > Automated cloud flow.Provide a clear, descriptive flow name. In the trigger search bar, enter SharePoint and select the specific When an item is created - SharePoint trigger.Select Create to launch the designer.
2. Configure the Trigger: Click on the trigger card on the canvas. In the left-hand Configuration Pane, populate the Site Address and List Name from the provided dropdown menus.Ensure your Microsoft Entra ID account has adequate permissions to read the target list.
3. Add the Action: On the central canvas, hover over the blue dashed line and select the + icon beneath the trigger. The Add an action pane will appear on the left. Navigate to the By connector tab, search for Microsoft 365 Outlook, and select the Send an email (V2) action.
4. Map Dynamic Content: In the email configuration pane, place your cursor in the Body or To field. Select the lightning bolt icon (Insert dynamic content) or use the keyboard shortcut / to open the context menu.Select relevant columns exposed by the SharePoint trigger (e.g., Title, Created By) to populate the email dynamically.

AI and Copilot Simplifications: Instead of manually searching for triggers, navigating through action menus, and mapping basic fields, developers can now build this entire sequence instantly using Copilot. On the make.powerautomate.com Home screen, a maker can simply type a natural language prompt.

For example, typing: "Create a flow that triggers when a new item is added to my SharePoint list and sends an email via Outlook containing the item details" will initiate the AI engine.Copilot generates the structural flow, pre-configures the necessary connector authentications, and opens the New Designer for final parameter mapping and verification.

3. Building an Instant Cloud Flow (Manual / Button Trigger)

The third session module demonstrated how to build an automation that executes only when a user explicitly demands it. This involves clicking a virtual button on a mobile device, or selecting a specific item within a Microsoft 365 application context.

Recapping the Demonstration:

The speaker showcased an instant flow utilizing a manual button trigger. This allowed the end-user to initiate a complex background process on-demand, passing manual input variables into the workflow at runtime.

The March 2026 Build Process:

Instant flows remain critical for processes that require human initiation but automated execution. The configuration of inputs has been streamlined in the new configuration pane.

1. Select the Trigger: Navigate to Create > Instant cloud flow.For a mobile or desktop button, select Manually trigger a flow. For deep SharePoint integration, select the For a selected item trigger.
2. Configure Input Parameters: Click the trigger card to open the left configuration pane. Select Add an input. Makers can force users to provide specific data before the flow executes, requiring text strings, dropdown selections, file uploads, or dates.
3. Build Downstream Logic: Add actions exactly as you would in an automated flow. For instance, you might take the text input from the manual trigger and use it to create a new task in Microsoft Planner, or post an adaptive card to Microsoft Teams.

Crucial 2026 Context for SharePoint Integration: When utilizing the For a selected item trigger, the flow allows end-users to trigger automation directly from the command bar of a SharePoint list or document library. However, strict architectural governance rules apply in 2026. Flows utilizing this specific trigger will only appear in the SharePoint UI if the flow is housed within the tenant's Default Environment. If you build the flow in a dedicated production, developer, or sandbox environment, it will not render in the SharePoint command menu natively, leading to significant deployment confusion.

4. Building a Scheduled Cloud Flow

The session detailed how to run workflows on a strict temporal basis. This mimics traditional cron jobs or scheduled scripts to execute data synchronization tasks at specific, recurring intervals.

Recapping the Demonstration:

The speaker configured a scheduled flow to run daily. This automated a repetitive reporting task that required no human intervention or external system event triggers.

The March 2026 Build Process:

Scheduled flows in 2026 offer highly granular temporal controls. They ensure processes kick off exactly when required, regardless of the maker's local time zone.

1. Initiate the Schedule: Navigate to My flows > New flow > Scheduled cloud flow.
2. Define the Recurrence: A configuration window requires a Starting date and time, alongside a Repeat every interval (e.g., 1 Week, 1 Day, 1 Month). Populate these fields and select Create.
3. Advanced Temporal Configuration: The designer opens with the Recurrence trigger on the canvas. Selecting it opens the left configuration pane. To ensure absolute precision, makers must specify the Time Zone dropdown. This dictates whether the start time follows local time or Coordinated Universal Time (UTC), which is critical for global deployments.
4. Granular Execution Limits: Using the advanced parameters in the configuration pane, developers can select specific days of the week, and exact hours (e.g., 08, 15) and minutes (e.g., 00, 30) for execution. The start time format strictly requires standard ISO 8601 formatting, such as 2026-03-24T22:00:00Z.

AI and Copilot Simplifications:

Copilot handles temporal logic and cron formatting exceptionally well. A developer can bypass the manual scheduling configuration screens entirely by using a detailed natural language prompt.

From the designer, prompt Copilot: "Create a flow that runs Monday every week starting 04/14/2026 which sends an email to contoso@gmail.com that their MPR doc is due". Once the flow is generated, the developer can refine the schedule purely through chat. By typing: "Change the interval from every week to 2 weeks," Copilot will update the underlying JSON schedule configuration automatically, saving significant clicks.

5. Adding Flow Controls (Conditions, Apply to Each, Do Until)

The original session demonstrated how to make flows intelligent by introducing branching logic, iterating over arrays of data, and executing tasks until a specific system state was achieved. This is the area where the 2026 New Designer has seen the most dramatic structural changes and usability improvements.

Recapping the Demonstration:

The speaker implemented an Apply to each loop to process a retrieved list of items. They used a Condition to evaluate values within that loop, and set up a Do until loop for iterative approval processing.

The March 2026 Build Process:

Flow controls dictate the logical path of the automation. They require a strong understanding of how arrays and boolean logic function within the Power Platform.

A. Conditions (If/Then Logic)

1. Implementation: On the canvas, click the + icon, navigate to Add an action > Built-in tools, and select Condition.
2. Configuration: The control visually splits the flow into two distinct vertical paths: True and False. In the left configuration pane, select a dynamic content field (e.g., Subject), an operator (e.g., contains), and a required value (e.g., meet now).
3. Expression Editor: For complex logic requiring data manipulation, developers must utilize the new multi-line expression editor. Selecting the fx button opens an expanded text box with a 'gripper' to resize the window.
4. Copilot Expression Assistant: Writing complex or(), and(), and empty() functions manually is often prone to syntax errors. By selecting Create expression with Copilot within the editor, a developer can simply type: "Grab the last four characters of Phone Number and convert it to a string." Copilot will instantly generate the exact, syntactically correct Power Automate expression formula.

B. Apply to Each (Looping Arrays)

1. Implementation: Navigate to Add an action > Built-in tools > Apply to each.
2. Configuration: This action strictly requires an array input. Developers map it to an array returned by a previous step (for example, the value array from a 'Get emails' or 'Get items' list action). The loop will execute all nested actions sequentially for every single item in that array.

C. Do Until (Iteration)

The Do until loop has received a major architectural correction in the New Designer. Historically, in the classic UI, it visually appeared as though the condition was checked before the loop executed. In reality, a Do until loop always executes its nested actions at least once before evaluating the condition. The 2026 designer visually corrects this discrepancy, placing the condition block after the nested actions to accurately reflect the true execution flow.

1. Implementation: Navigate to Add an action > Built-in tools > Do until.
2. Configuration: Establish the break condition in the left pane (e.g., Variable Counter is equal to 3).
3. Limit Management: A Do until loop will not run infinitely. By default, it operates under two strict safety limits to prevent runaway compute consumption. The Count limit caps execution at a maximum of 5,000 iterations. The Timeout limit defaults to PT1H (1 hour, following ISO 8601 duration formatting). The loop forcefully terminates if either limit is reached, regardless of whether the primary condition evaluates to true.

Architectural Correction: The 'Do Until' Loop in 2026

The New Designer visually resolves a longstanding logic flaw. By moving the condition check to the bottom of the structure, it accurately reflects that the enclosed actions will always execute at least once before the loop terminates.

Data sources: SharePains

6. Testing, Debugging, and Sharing Flows

The final demonstrations in the session revolved around validating the workflow, handling operational errors, and distributing the automation to the wider organization safely.

Recapping the Demonstration:

The speaker executed a manual test run, inspected the run history to trace data movement, identified a deliberate failure point, and subsequently shared the flow with another user to demonstrate collaboration.

The March 2026 Build Process:

The debugging experience has shifted from manually deciphering code to interacting with intelligent diagnostic agents.

A. Testing and Debugging

1. Execution Validation: Once a flow is successfully saved (indicated by a green checkmark in the designer resiliency banner), the Test button on the top command bar becomes active. Makers can test the flow manually by performing the trigger action (e.g., sending a test email to themselves) or automatically by re-running a previously successful JSON payload.
2. Run History Analysis: Flow performance is tracked via the 28-day run history dashboard. Failed runs are prominently marked with a red exclamation icon. Selecting a failed run opens the detailed execution graph, highlighting the exact node where the logic collapsed.
3. Troubleshooting Copilot: Debugging in 2026 no longer requires extensive knowledge of JSON schema or HTTP status codes. When an action fails, the right-hand pane displays the Troubleshooting Copilot. This specialized AI agent analyzes the failure context—whether it's an Authentication Error 401, an Action Configuration Error 400, or a transient Error 502—and outputs a human-readable summary. For example, if an OAuth token expires, the Copilot will directly suggest: "Fix Connection," providing a one-click button to re-authenticate the specific node without leaving the canvas.

B. Sharing and Permissions

Sharing cloud flows in 2026 is categorized into distinct permission models, governed strictly by Microsoft Entra ID policies to prevent data leakage.

1. Co-ownership: To allow colleagues to edit the flow logic, developers add them as Owners. Owners can modify the flow, alter run-after settings, and utilize embedded connections. However, they cannot extract or modify the raw credentials of connections established by the original author.
2. Run-Only Users (Instant Flows Only): For manual button flows or SharePoint selected item triggers, developers assign Run-Only Users. These users can trigger the flow but have zero visibility into the underlying architecture or code. Crucially, in 2026, administrators can dictate whether the flow executes using the embedded service account connections, or if the run-only user must authenticate and pass their own context. This prevents users from utilizing a developer's elevated privileges to access SharePoint lists they shouldn't see.
3. Security Group Integration: The modern best practice for managing run-only access avoids adding individual users. Instead, developers assign a Microsoft Entra ID Security Group to the Run-Only profile. As human resources onboards or offboards employees from the group, their access to execute the flow is automatically granted or revoked. Ensure that environment routing policies allow the target security group to access the specific Dataverse environment housing the flow.

---

Licensing Quick Reference

Power Automate licensing remains a complex topic. Selecting the most cost-effective license requires assessing three fundamental operational factors: the necessity of Premium connectors (like Dataverse or SQL), the scale of deployment (the total number of users triggering the automation), and the need for legacy desktop application automation (RPA).

If your workflow requires standard connectors like SharePoint and Outlook, the basic M365 Seeded license is sufficient. However, if you require Premium integrations and have more than 35 users triggering the flow, the Per Flow plan becomes significantly more cost-effective than licensing each individual user. If RPA is required to scrape data from a legacy terminal, the Per User with RPA plan is mandatory.

The following matrix details the primary commercial licensing models available as of March 2026.

The shift from 2021 to 2026 has repositioned Power Automate from a simple logic-routing tool to a highly advanced, AI-driven automation engine. By leveraging the New Designer, optimizing loops through concurrency, implementing trigger conditions to preserve API capacity, and leaning heavily on Copilot for expression writing and debugging, developers can construct robust, enterprise-grade solutions at unprecedented speeds.