The Power Automate Desktop Recorder converts your mouse clicks and keystrokes into reusable automation steps — no coding required. Learn how to record, clean up, and reliably replay desktop interactions in this hands-on foundation lesson.
Picture this: every morning, your team manually opens a legacy inventory management system, clicks through four nested menus, types a date range into two separate fields, hits "Generate Report," waits for the results, and then copies the output into a shared spreadsheet. It takes about twelve minutes per person, happens five days a week, and nobody enjoys it. The process is perfectly consistent — which is exactly the kind of thing computers are great at.
The Power Automate Desktop Recorder is the fastest way to turn that kind of repetitive, click-heavy process into an automated desktop flow. It watches what you do — every mouse click, every keystroke, every UI interaction — and converts those actions into a structured list of steps that the bot can replay on demand. You don't need to write a single line of code to get started. You just do the thing, and the recorder writes the automation for you.
By the end of this lesson, you'll know how to record a real interaction, understand what the recorder actually captures and why, clean up and edit the recorded steps, and run a reliable replay. You'll also know where the recorder falls short and how to supplement it with smarter techniques.
What you'll learn:
This lesson assumes you have Power Automate Desktop installed and have successfully created and run at least one simple flow. If you haven't done that yet, start with Getting Started with Power Automate Desktop: Installing, Recording, and Running Your First Desktop Flow before continuing here.
You should also have a basic sense of what a desktop flow is and how the flow designer is laid out. No programming experience is needed.
Before you hit the Record button, it's worth understanding what's happening behind the scenes. When you start a recording session, Power Automate Desktop activates a system-level hook that monitors your mouse and keyboard input in real time. Every time you click something, it doesn't just record "click at coordinates (847, 312)." Instead, it identifies what you clicked — the window it belongs to, the control type (button, text field, dropdown, checkbox), and the control's identifier within the application.
This distinction matters enormously. If the recorder only stored raw pixel coordinates, your automation would break the moment a window was resized, a screen resolution changed, or someone moved the application to a different monitor. Instead, the recorder stores a UI element — a description of the control's identity within the application's UI hierarchy. This is the same selector-based approach used throughout Power Automate Desktop's UI automation engine.
For keystrokes, the recorder captures the text you typed and associates it with the specific field you were focused on. So instead of "press F, r, e, d," you get "populate text field 'Username' with 'Fred.'"
Key insight
The recorder's output quality depends heavily on the application you're recording against. Well-structured applications with accessible UI controls produce clean, reliable selectors. Poorly built or very old applications may produce fragile positional selectors. We'll talk about how to deal with this in the troubleshooting section.
Open Power Automate Desktop and either create a new flow or open an existing one. You'll land in the flow designer — the canvas where your actions live.
At the top of the designer, you'll see a toolbar. Look for the Recorder button (it shows a circular record icon). Click it, and a small floating Recorder panel appears. This panel stays on top of every other window so you can see it while interacting with your application.
The Recorder panel has three main controls:
Before you click Record, get everything ready. Open the application you want to automate. Navigate to the starting point — wherever the bot should begin each time it runs. Think of this as "staging the scene" before the cameras roll.
Tip
Always start your recording from a consistent, known state. If your bot is going to open an application from scratch, include that step manually or record it as the very first action. Starting mid-process leads to flows that only work if a human has already done the setup.
Let's walk through a concrete example. Imagine you're automating data entry into a Windows-based HR system — a classic desktop app with text fields, dropdowns, and a Save button.
Step 1: Stage the application. Open the HR system. Navigate to the employee data entry screen. Position the window so it's fully visible and not obscured by anything.
Step 2: Start the recording. Click Record in the Recorder panel. A red indicator appears, and the panel shows "Recording in progress."
Step 3: Perform the actions you want to automate. Click the "Employee ID" field and type EMP-2047. Press Tab to move to the "Department" dropdown and select "Operations." Click the "Start Date" field and type 01/15/2025. Click the Save button.
Step 4: Pause to review (optional). You can click Pause mid-recording to check what's been captured so far without ending the session. This is useful for long recordings.
Step 5: Click Done. The Recorder closes and deposits a series of actions into your flow.
Here's roughly what those imported actions look like in the designer:
Click UI element: Text field 'EmployeeID' in window 'HR System'
Populate text field: 'EmployeeID' with 'EMP-2047'
Click UI element: Dropdown 'Department' in window 'HR System'
Select list item: 'Operations' in Dropdown 'Department'
Click UI element: Text field 'StartDate' in window 'HR System'
Populate text field: 'StartDate' with '01/15/2025'
Click UI element: Button 'Save' in window 'HR System'
Each action is now a configurable step. Double-click any of them to open its properties and modify what it does.
Note
You'll often see the recorder generate both a "Click" action and a "Populate text field" action for the same field. The click brings focus to the field; the populate fills it. In many cases you can delete the click and keep only the populate — Power Automate Desktop will click-to-focus automatically. But test before removing clicks, because some older applications require the explicit click to register properly.
If your process happens in a web browser, the Desktop Recorder still works, but Power Automate Desktop also offers a dedicated Web Recorder that produces cleaner, more semantic actions for browser content.
To use the Web Recorder, make sure you have the Power Automate Desktop browser extension installed (available for Chrome, Edge, and Firefox). When you launch the Recorder and then interact with content inside a browser, the tool automatically switches to web-aware mode. Instead of recording generic UI clicks, it captures actions like:
Click link 'Monthly Reports' on web page 'http://intranet.company.com/reports'
Populate text field 'SearchTerm' with 'January 2025'
Click button 'Submit' on web page 'http://intranet.company.com/reports'
These web actions use CSS selectors and DOM attributes to identify elements, which is much more resilient than screen coordinates. For deep coverage of browser automation, see Web Automation in Power Automate Desktop: Browser Actions, Form Filling, and Data Extraction.
Warning
Don't record through a browser without the extension installed. You'll get raw UI clicks against the browser window frame rather than meaningful web element interactions, and those recordings are notoriously fragile. Always verify the extension is active before starting a web recording session.
The recorder gives you a starting point, not a finished product. Treat the imported actions the way you'd treat a rough draft — useful raw material that needs editing before it's ready for real use.
Here are the most common edits you'll make:
The recorder captures exactly what you typed, which means your recorded flow has the literal values baked in: EMP-2047, 01/15/2025, Operations. For a one-time automation, that's fine. For anything you'll run repeatedly with different data, you need to replace those literals with variables.
Open the "Populate text field" action for the Employee ID. You'll see a "Text to populate" field containing EMP-2047. Replace that with %EmployeeID% — the percent signs tell Power Automate Desktop that this is a variable reference, not a literal string.
Now create an input variable called EmployeeID (or read its value from a file, database, or another system). Each time the flow runs, it will fill the field with whatever value that variable holds. For a thorough guide to working with variables, see Variables, Lists, and Data Tables in Power Automate Desktop: A Complete Practitioner's Guide.
The recorder captures everything you did, including navigational fumbles. If you clicked the wrong field before clicking the right one, both clicks are in the recording. Review the action list carefully and delete anything that isn't part of the intended process.
Also look for duplicate "Click + Populate" pairs on fields that don't need the explicit click. Clean those up to reduce unnecessary overhead.
By default, recorded actions have generic names. Right-click any action and choose "Rename" to give it a meaningful label like "Enter Employee ID" or "Click Save Button." This makes the flow readable to anyone who maintains it later — including future you.
If the recorder captured interactions across multiple windows or dialogs, make sure each action references the correct window. If the window title changes dynamically (for example, it includes the current date or document name), you may need to update the window selector to use a wildcard or a more stable attribute. This is where UI Elements and Selectors in Power Automate Desktop: Building Automations That Don't Break becomes essential reading.
With your edits in place, it's time to run the flow and verify it behaves correctly.
Click the Run button (the triangle/play icon) in the designer toolbar. The flow will execute from the top. Watch carefully — Power Automate Desktop will highlight each action as it executes, making it easy to spot where things go wrong.
For step-by-step debugging, use the Step Into button (the arrow-down icon) instead of Run. This executes one action at a time and pauses after each, letting you inspect what happened before moving on. This is invaluable when a recording has twenty steps and only step fourteen is misbehaving.
Tip
Set a breakpoint on a specific action by right-clicking it and selecting "Toggle breakpoint." When you run the flow, it will execute normally until it hits the breakpoint, then pause. This is faster than stepping through the entire flow when you know roughly where the problem is.
Common things to watch for during a test run:
For timing issues, you can insert a Wait action between steps, or better yet, use a Wait for UI element action that pauses until a specific control appears on screen. This is more reliable than fixed time delays because it adapts to actual application performance rather than hoping a two-second sleep is always enough.
The recorder is a fantastic starting point, but it has real limitations you should understand before relying on it for production automation.
It captures what you did, not what you meant. If you accidentally moved your mouse over a tooltip during recording, that interaction might be in there. If you hesitated for three seconds before clicking, the recorder captured the hesitation. The output is a literal transcript of your session, not an intelligent interpretation of your intent.
It struggles with dynamic content. If the application shows different controls depending on data or state — for example, a field that only appears when a certain checkbox is ticked — the recorder won't know to handle that conditional logic. You'll need to add conditions and loops manually after recording.
Legacy applications can produce fragile selectors. If you're working with very old Windows applications built before modern accessibility standards, the recorder may fall back to screen coordinates. Those break immediately when anything about the screen layout changes. See Automating Legacy Windows Applications with UI Automation in Power Automate Desktop for strategies to handle this properly.
It doesn't add error handling. A recorded flow will crash completely if something unexpected happens — a network timeout, a missing record, an application error message. You need to add error handling yourself after recording. Think of the recorder as getting you 70% of the way there; solid error handling and dynamic logic take you the rest of the way.
Key insight
The best way to use the recorder is as a scaffolding tool. Record the happy path to get the structure quickly, then spend time refining the output: replace literals with variables, add error handling, strengthen selectors, and insert waits. The recording cuts your development time dramatically — just don't ship it unedited.
Let's put this into practice with a complete, self-contained exercise you can do right now using Notepad — a universal Windows application that's always available.
Scenario: Automate entering a simple daily log entry into Notepad — a timestamp, a category, and a note — then save the file.
Step 1: Prepare. Open Notepad. Create a new blank file. Position the window so it's fully visible.
Step 2: Record.
Open Power Automate Desktop and create a new flow. Click the Recorder button and then click Record. Switch to Notepad. Type the following: 2025-01-15 | OPERATIONS | Inventory reconciliation complete. Press Enter. Back in the Recorder panel, click Done.
Step 3: Review the recorded actions. You should see something like:
Set focus on window: 'Untitled - Notepad'
Populate text field with: '2025-01-15 | OPERATIONS | Inventory reconciliation complete'
Send keys: {Return}
Step 4: Parameterize.
Create three input variables: LogDate, LogCategory, and LogNote. Edit the "Populate text field" action and replace the hardcoded text with:
%LogDate% | %LogCategory% | %LogNote%
Step 5: Add a Save step.
The recorder didn't capture a Save action because you didn't do one during recording. Add it manually: in the Actions panel on the left, search for "Send keys" and drag it in. Configure it to send {Control}({S}) — the keyboard shortcut for Save. When Notepad's Save dialog appears, you can either handle it with additional actions or pre-configure Notepad to save to a known path.
Step 6: Run and verify.
Set test values for your three variables (LogDate = "2025-01-16", LogCategory = "FINANCE", LogNote = "Budget review completed"). Run the flow and confirm Notepad fills in correctly.
This exercise demonstrates the core recorder workflow: record the skeleton, clean it up, add variables, and fill in the gaps the recorder missed.
Warning
If Notepad is already open with existing content when you run the flow, the bot will append to whatever is there. For a real automation, you'd want to include logic at the start to open a fresh document or navigate to the correct file. Always think about the state of the world before your bot starts running.
The flow runs but nothing happens. Usually this means the application window isn't in focus or the UI element selector is stale. Check whether the application is actually open and on screen. Try adding a "Focus window" action before the first interaction.
Actions fail with "Element not found." The selector the recorder captured no longer matches anything on screen. This can happen if the application was updated, if you're running on a different machine, or if a window title changed. Double-click the failing action and use the "Recapture" button next to the UI element to re-identify the control.
The bot types into the wrong field. The recorder's click sequence may have been captured in a way that leaves focus on the previous field. Add an explicit Click action targeting the correct field before the Populate action.
Text is being typed too fast for the application to register. Some older applications don't handle rapid programmatic input well. Open the "Populate text field" action properties and look for a typing delay option. Setting a small delay (50–100 milliseconds between keystrokes) often resolves this.
The recorder captured my entire session including pauses and mistakes. Always review the action list after recording and delete anything that doesn't belong. The recorder is honest — it captures everything, good and bad.
The flow works on my machine but fails on the server. This is a common issue when moving to unattended RPA. The application might not be installed on the target machine, the screen resolution might differ, or the application might not launch automatically. Test your flows on the exact machine they'll run on.
The Power Automate Desktop Recorder is one of the fastest ways to turn a manual, repetitive desktop task into an automated flow. You've now learned how it captures UI elements rather than raw coordinates, how to launch a recording session and interact naturally with an application, what the resulting actions look like and how to interpret them, and how to edit those actions to be variable-driven, clean, and production-ready.
More importantly, you understand the recorder's limits: it produces a first draft, not a finished automation. The real work is in the refinement — replacing hardcoded values, strengthening selectors, adding conditional logic, and building in error handling.
From here, here are the natural next topics to explore:
The recorder gives you momentum. What you build from that momentum is up to you.