Scheduling and Running Desktop Flows from Cloud Flows on a Timer: Configuring Recurrence Triggers, Passing Runtime Parameters, and Logging Results to SharePoint

Introduction

Picture this: your team has a reporting process that runs every morning at 7 AM. Someone has to log into a legacy ERP system, pull yesterday's transaction data, paste it into an Excel template, and email the results to three different managers. Right now, that someone is a human being — setting an alarm, sipping coffee before they're ready, and doing the exact same 23 steps they did yesterday and will do again tomorrow.

You've already built a desktop flow in Power Automate Desktop that handles those 23 steps flawlessly. But it only runs when you manually press "Run." That's better than doing it by hand, but it's not automation — it's delegation to a slightly faster version of yourself. True automation means the process runs on a schedule, without anyone touching it, and leaves a clear audit trail so you can prove it worked (or diagnose why it didn't).

By the end of this lesson, you'll be able to wire a cloud flow to a recurrence trigger, have that cloud flow call your desktop flow at a scheduled time while passing in runtime parameters (like the target date or report type), and write the results of every run to a SharePoint list so you have a permanent, queryable log.

What you'll learn:

• How to configure a Recurrence trigger in a cloud flow and control its timing precisely
• How to pass input parameters from a cloud flow into a desktop flow at runtime
• How to capture output variables returned from a desktop flow back into the cloud flow
• How to create a SharePoint list structure that serves as an effective automation log
• How to write run results — including success/failure status and output data — to SharePoint after every execution

---

Prerequisites

Before diving in, you should be comfortable with the basics of Power Automate Desktop. If you haven't built and tested a desktop flow yet, work through Getting Started with Power Automate Desktop: Installing, Recording, and Running Your First Desktop Flow first.

You should also understand how cloud flows invoke desktop flows. The mechanics of that connection — how inputs travel from cloud to desktop and outputs travel back — are covered in detail in Triggering Desktop Flows from Cloud Flows: Passing Inputs and Returning Outputs. Read that article if you haven't already, because this lesson builds directly on top of it.

Finally, you'll need:

• A Power Automate license that includes desktop flow runs (Premium or per-flow)
• A registered machine or machine group with the Power Automate Desktop agent running
• A SharePoint site where you have permission to create lists
• A desktop flow that has at least one input variable and produces at least one output variable

---

Understanding the Architecture Before You Build

When you run a desktop flow manually from the Power Automate Desktop designer, the cloud layer isn't involved at all — you're just executing locally. The moment you want scheduling, logging, or orchestration, you need a cloud flow: a flow that lives in the Power Automate cloud service and can react to triggers, call connectors, and coordinate logic across services.

Think of the cloud flow as a conductor and the desktop flow as a musician. The conductor decides when to start, tells the musician what piece to play (the input parameters), listens for the result, and then writes a note in the performance log (SharePoint). The musician — your desktop flow — never needs to know what time it is or where the log lives. It just does its job with the instructions it was given.

This separation of concerns is the right design. Your desktop flow stays focused on UI automation. Your cloud flow handles scheduling, parameter injection, and result persistence. When something goes wrong, you know exactly which layer to investigate.

---

Step 1: Preparing Your Desktop Flow with Input and Output Variables

Before scheduling anything, your desktop flow needs to be built to receive parameters and return results. Let's use a concrete example: a flow that logs into a legacy inventory system, pulls the day's stock counts for a given warehouse code, and returns both the total item count and a status message.

Open your desktop flow in Power Automate Desktop. To create an input variable (a value the cloud flow will send at runtime), click the Variables panel on the right side of the designer, then click the plus icon and choose "Input/output." Fill in:

• Variable name: WarehouseCode
• Data type: Text
• Input/Output: Input
• Default value: WH-001 (used when running locally for testing)
• Description: "The warehouse identifier to pull stock counts for"

Create a second variable for the report date:

• Variable name: ReportDate
• Data type: Text
• Input/Output: Input
• Default value: Leave blank or use today's date in YYYY-MM-DD format

Now create output variables that your flow will populate before it finishes:

• Variable name: TotalItemCount

• Data type: Number

• Input/Output: Output

• Variable name: RunStatus

• Data type: Text

• Input/Output: Output

Inside your desktop flow logic, after extracting the inventory data, you'll assign values to these outputs. For example, after reading data from the legacy app, you might use a "Set variable" action to assign %RecordCount% to TotalItemCount and set RunStatus to "Success".

Understanding Variables, Lists, and Data Tables in Power Automate Desktop will help you manage more complex output scenarios — particularly when you need to return structured data rather than simple strings.

---

Step 2: Creating a SharePoint List for Run Logging

Before building the cloud flow, set up the destination for your logs. A SharePoint list is ideal because it's queryable, visible to non-technical stakeholders, and integrates natively with Power Automate.

Go to your SharePoint site and create a new list called Automation Run Log. Beyond the default "Title" column, add these columns:

Column Name	Type	Purpose
FlowName	Single line of text	Which automation ran
RunDate	Date and Time	When the run was triggered
WarehouseCode	Single line of text	Input parameter used
ReportDate	Single line of text	Input parameter used
TotalItemCount	Number	Output from the desktop flow
RunStatus	Single line of text	"Success", "Failed", or "Partial"
ErrorDetail	Multiple lines of text	Error message if run failed
DurationSeconds	Number	How long the run took

You can name the Title column "RunID" or leave it as Title and populate it with a generated identifier like WH-001-20250115.

---

Step 3: Building the Cloud Flow with a Recurrence Trigger

Now you're ready to build the orchestrating cloud flow. Navigate to make.powerautomate.com, click "Create" in the left navigation, and choose "Scheduled cloud flow."

Give your flow a descriptive name — something like Daily Inventory Bot - Warehouse Run. In the "Run this flow" section, configure:

• Starting: Today's date at 07:00 AM
• Repeat every: 1 Day

Click "Create." You'll land in the cloud flow designer with a Recurrence trigger already placed.

Fine-Tuning the Recurrence Trigger

Click on the Recurrence trigger to expand its settings. Switch the view to "Show advanced options." Here you'll find additional controls that most beginners miss:

Time zone: By default, recurrence runs in UTC. If your business is in Eastern Time and you want the flow to run at 7 AM Eastern, you must set the time zone explicitly. Set it to "(UTC-05:00) Eastern Time (US & Canada)" and set the "At these hours" field to 7. Leave "At these minutes" as 0.

Days of the week: If you only want weekday runs, change the "Frequency" to "Week" and set "On these days" to Monday, Tuesday, Wednesday, Thursday, Friday.

Adding Variables for Run Tracking

After the Recurrence trigger, add an "Initialize variable" action. Name it RunStartTime and set its type to String. For the value, use the expression:

utcNow()

This captures when the run began. You'll use this later to calculate duration.

Add another "Initialize variable" action named ErrorDetail of type String, with an empty default value. This variable will be populated only if the desktop flow fails.

---

Step 4: Calculating and Passing Runtime Parameters

One of the most powerful aspects of this architecture is that the cloud flow can compute what parameters to send based on context — rather than hardcoding them.

For our inventory example, the ReportDate should be yesterday's date (we're pulling yesterday's transactions each morning). Add a "Compose" action and enter this expression:

formatDateTime(addDays(utcNow(), -1), 'yyyy-MM-dd')

This takes today's UTC date, subtracts one day, and formats it as 2025-01-14. Name this Compose action YesterdayDate. You'll reference its output as the ReportDate input to your desktop flow.

For WarehouseCode, you might hardcode it here, pull it from a SharePoint configuration list, or even loop through multiple warehouse codes (running the desktop flow once per warehouse). For now, let's set it as a hardcoded string WH-001 using another Compose action named TargetWarehouse.

---

Step 5: Calling the Desktop Flow

Add a new action by clicking the plus sign below your Compose actions. Search for "desktop flows" and select "Run a flow built with Power Automate Desktop."

In the action configuration:

• Desktop flow: Select your inventory flow from the dropdown. If it doesn't appear, verify it's been saved and published in Power Automate Desktop.
• Run mode: Select "Unattended" if your machine supports it and no one will be logged in at 7 AM. Select "Attended" if someone will be at the machine. If you're unsure about the trade-offs, Attended vs Unattended RPA: Choosing a Run Mode and Configuring Machines in Power Automate explains the distinction thoroughly.
• WarehouseCode: Click in the field and select the output of your TargetWarehouse Compose action using dynamic content.
• ReportDate: Select the output of your YesterdayDate Compose action.

When you save this action, Power Automate reads the input/output variable definitions from your desktop flow and presents them as named fields. This is why getting the variable definitions right in Step 1 matters so much — the cloud flow interface is driven entirely by what the desktop flow declares.

---

Step 6: Capturing Outputs and Handling Errors

The "Run a flow built with Power Automate Desktop" action returns the output variables your desktop flow defined. After this action completes successfully, you can reference TotalItemCount and RunStatus directly in subsequent actions using the dynamic content panel.

But flows don't always succeed. Wrap the desktop flow action in a Scope block and configure error handling:

1. Click the three dots on the "Run desktop flow" action and select "Configure run after."
2. Add a parallel branch that runs "if the previous action failed."

In the failure branch, add a "Set variable" action targeting ErrorDetail and populate it with the expression:

outputs('Run_a_flow_built_with_Power_Automate_Desktop')?['error']?['message']

This expression pulls the error message from the failed action's output. If the machine was unavailable, a selector broke, or the desktop flow threw an unhandled exception, that message lands in ErrorDetail.

For robust error handling patterns inside the desktop flow itself, see Error Handling in Desktop Flows: On Block Error, Retry Policies, and Recovery Screenshots.

---

Step 7: Calculating Run Duration

After both the success and failure branches, add a "Compose" action in the main path to calculate how long the run took:

div(
  sub(
    ticks(utcNow()),
    ticks(variables('RunStartTime'))
  ),
  10000000
)

This expression computes the difference in ticks (100-nanosecond intervals) between now and when you captured RunStartTime, then divides by 10,000,000 to get whole seconds. Name this Compose action DurationSeconds.

---

Step 8: Writing Results to SharePoint

Now add the "Create item" action from the SharePoint connector. Configure it as follows:

• Site Address: Select your SharePoint site
• List Name: Automation Run Log
• Title: Use a dynamic expression like:

concat(outputs('TargetWarehouse'), '-', outputs('YesterdayDate'))

This creates a readable run identifier like WH-001-2025-01-14.

Map the remaining fields using dynamic content:

• FlowName: Type the literal string Daily Inventory Bot
• RunDate: Use utcNow() or the triggerOutputs()?['body/timestamp'] expression to get the trigger's exact fire time
• WarehouseCode: Select the TargetWarehouse Compose output
• ReportDate: Select the YesterdayDate Compose output
• TotalItemCount: Select the TotalItemCount output from the desktop flow action
• RunStatus: Select the RunStatus output from the desktop flow action (or use "Failed" in the error branch)
• ErrorDetail: Reference the ErrorDetail variable
• DurationSeconds: Reference the DurationSeconds Compose output

---

Testing Your Scheduled Flow Before Going Live

Don't wait until 7 AM tomorrow to find out if it works. Use the "Test" feature in the cloud flow designer.

Click the "Test" button in the top right corner of the flow editor. Choose "Manually" and click "Test." This fires the flow immediately, exactly as if the recurrence trigger had fired. Watch the run history in real time — each action shows green (success) or red (failure), and you can expand any action to see its inputs and outputs.

After a successful test, check your SharePoint list. You should see a new row with yesterday's date, the warehouse code, the item count, and a status of "Success."

If the desktop flow action shows "Connection failed" or "Machine unavailable," verify that your machine is registered, the Power Automate Desktop agent is running, and you're targeting the right machine group. Managing Machines and Machine Groups for Scalable Unattended Automation in Power Automate covers machine configuration in depth.

---

Hands-On Exercise

Build the following end-to-end automation using what you've learned:

Scenario: You have a desktop flow called DailyWebReport that navigates to an internal web portal, extracts a summary metric (say, the number of open support tickets), and sets an output variable TicketCount (Number) and ExtractStatus (Text — either "Success" or "NoData").

Your tasks:

1. Add the input variable TargetDate (Text) to the desktop flow to specify which date's data to pull
2. Create a SharePoint list called Bot Run History with columns for RunDate, TicketCount, ExtractStatus, ErrorDetail, and DurationSeconds
3. Build a cloud flow with a Recurrence trigger that fires every weekday at 8:00 AM in your local time zone
4. In the cloud flow, compute today's date formatted as MM/dd/yyyy (the format your portal expects) and pass it as TargetDate
5. Call the desktop flow in unattended mode
6. Write a log entry to Bot Run History regardless of whether the desktop flow succeeded or failed
7. Test the flow manually and verify the SharePoint entry appears correctly

Stretch goal: Add a condition after logging: if TicketCount is greater than 50, send an email notification to a manager using the Outlook connector.

---

Common Mistakes & Troubleshooting

The recurrence fires at the wrong time Almost always a time zone issue. Open the Recurrence trigger, click "Show advanced options," and verify the Time zone field is set explicitly. UTC is the default and catches many people off guard.

The desktop flow input fields don't appear in the cloud flow action This means the desktop flow either hasn't been saved/published, or the input variables weren't properly defined as Input type in the Variables panel. Re-open the desktop flow, verify each variable's Input/Output setting, save it, and then refresh the cloud flow action.

SharePoint "Create item" fails with a type mismatch If you're mapping TotalItemCount (a number from the desktop flow) into a SharePoint Text column, the connector may fail or store it oddly. Match your SharePoint column types to your desktop flow output types. Number outputs go to Number columns, text outputs go to single-line text columns.

The flow succeeds but I see no log in SharePoint Check whether the "Create item" action is inside a branch that only runs on success. If the desktop flow failed silently (e.g., returned a RunStatus of "Failed" without throwing an exception), and your cloud flow logic only logs on the success path, you'll miss entries. Always log unconditionally.

Duration shows a huge number If you forgot to divide by 10,000,000 in the ticks calculation, you'll see a 9-digit number instead of seconds. Double-check your formula. Alternatively, use the simpler approach of storing utcNow() at the start, utcNow() at the end, and computing the difference with the dateDifference expression if your environment supports it.

---

Summary & Next Steps

You've built something genuinely useful in this lesson. Your desktop flow now runs on a schedule without human intervention, receives context-appropriate parameters computed at runtime, and writes a permanent, queryable audit trail to SharePoint whether it succeeds or fails. That's the core loop of production RPA: trigger, parameterize, execute, log.

The pattern you've learned here scales. Want to run the same flow against five warehouses? Add a loop before the desktop flow action and iterate through an array of warehouse codes, calling the desktop flow once per iteration. Want to pause the schedule during holidays? Add a SharePoint configuration list with a PauseAutomation flag and check it at the top of your cloud flow. Want to alert on failures? Add a condition after the SharePoint write and send a Teams message if RunStatus equals "Failed."

From here, consider exploring:

• Attended vs Unattended RPA: Choosing a Run Mode and Configuring Machines in Power Automate — to understand when unattended mode is appropriate and what machine configuration it requires
• Error Handling in Desktop Flows: On Block Error, Retry Policies, and Recovery Screenshots — to make your desktop flow resilient enough that the cloud flow rarely sees failures in the first place
• Handling Credentials Securely in Desktop Flows: Sensitive Variables and Azure Key Vault — because if you're passing credentials as parameters to a scheduled flow, you need to understand how to do that without exposing secrets in plain text

The foundation is solid. Now build on it.