Can Copilot Build a Data Flow for You? An Honest Power Automate Test

Scenario: Monthly Customer Feedback Cleanup

Picture a small operations team:

• Customer feedback arrives via email from several channels.
• Each email has a CSV attachment with new rows for a central “CustomerFeedback” Excel file in OneDrive.
• The team currently:
  • Downloads each attachment.
  • Opens the main Excel file.
  • Copies rows from the CSV.
  • Deduplicates by TicketId.
  • Updates a status column and archives the CSV.

They want a cloud flow that:

1. Triggers when a new email arrives in a specific shared mailbox folder.
2. Saves the CSV attachment to an “Incoming” folder in SharePoint.
3. Appends new rows to a structured Excel table.
4. Marks imported rows with an ImportedOn timestamp.
5. Moves the processed attachment to an “Archive” folder.

We’ll see how far Copilot gets from a natural-language description, and where you still need to drive.

How Copilot Actually Works in Power Automate Today

Before testing, it’s worth being precise about what Copilot in Power Automate can and can’t do as of late 2026.

Where you see Copilot

You’ll typically encounter Copilot in cloud flows in three places:

• Create from description: In the Power Automate portal you can describe a flow in natural language, and Copilot proposes a draft flow.
• Copilot side panel in the designer: You can ask Copilot to add steps, modify existing ones, or explain the flow.
• Within some actions: For example, composing expressions or suggesting parameters.

Behaviour depends on environment configuration and licensing (e.g., AI features can be disabled or limited), but the pattern is consistent: Copilot generates a starting point, not a guaranteed working solution.

What Copilot is good at

Copilot tends to be accurate when:

• The flow follows a simple event → action pattern.
• Triggers and actions are among common connectors (Outlook, SharePoint, OneDrive, Teams, Excel Online, Dataverse).
• You describe the flow clearly with concrete entities: mailbox, folder, library, file, columns.

What Copilot is not good at (yet)

You should expect to do manual work when:

• The scenario needs data transformation beyond trivial mapping.
• You rely on connector nuances (e.g., Excel limitations, pagination, concurrency, dynamic content quirks).
• You need robust error handling, retries, or idempotency.
• You need to respect performance or capacity limits.

Copilot doesn’t change connector capabilities. If an action can’t do what you ask, Copilot either:

• Picks a different action that approximates the intent.
• Leaves placeholders you must fix.
• Or simply produces a step that won’t validate.

Test 1: “When an email arrives, append CSV rows to Excel”

Let’s feed Copilot a realistic description.

The prompt

From the Power Automate portal, choose Create → Copilot (or equivalent entry point) and describe:

"When a new email arrives in the shared mailbox 'support@contoso.com' in the folder 'Feedback', save any CSV attachments to a SharePoint document library 'CustomerFeedback/Incoming'. Then append the rows from the CSV into an existing Excel file 'CustomerFeedback.xlsx' in the same library, in the table 'FeedbackTable'. After importing, move the attachment to 'CustomerFeedback/Archive'."

What Copilot usually builds

On current behaviour, Copilot tends to propose a flow along these lines:

1. Trigger: When a new email arrives in a shared mailbox (V2) (Outlook connector).
2. Condition: Check the folder and attachment presence.
3. Action: Create file in SharePoint for each attachment.
4. Placeholder for CSV handling: Often a generic action like Get file content and a suggestion to “parse CSV”, but not an actual parsing implementation.
5. Excel step: Either:
   • Add a row into a table (Excel Online (Business)), or
   • A suggestion to “append rows” without correctly handling multiple CSV rows.
6. Action: Move file in SharePoint from Incoming to Archive.

Where Copilot gets it right

For this scenario, Copilot usually:

• Correctly selects the shared mailbox trigger, not the personal mailbox trigger.
• Uses SharePoint rather than OneDrive when you mention a document library.
• Creates a reasonable control flow:
  • Trigger → check attachments → create file → later steps.
• Suggests the right Excel connector (Excel Online (Business)) and the Add a row into a table action.

This is enough to save you several minutes of hunting for the right trigger and actions.

Where Copilot fails for data flows

The weak points are exactly where an experienced practitioner will care:

1. CSV parsing is not automatic

   • Copilot does not reliably generate a working CSV-to-rows implementation.
   • At best, it suggests using Power Automate expressions or a Create CSV table / Parse JSON combination that doesn’t match your actual file format.
   • It rarely handles delimiters, headers, or quoted fields correctly.

2. Multiple rows vs single row

   • The Add a row into a table action adds one row per invocation.
   • Copilot often wires dynamic content from the entire CSV file into that action, which is invalid.
   • It doesn’t automatically create an Apply to each loop over parsed rows.

3. Excel connector constraints

   • The Excel Online (Business) connector requires:
     • The file to be in OneDrive for Business or SharePoint.
     • A formatted table (not just a range).
   • Copilot doesn’t check that the table exists or that the file is accessible in the target site.

4. Idempotency and deduplication

   • Copilot doesn’t add logic to avoid duplicate imports if the flow re-runs or if the same attachment arrives twice.

So the answer to “Can Copilot build a data flow for you?” here is: it builds the skeleton but not the working data pipeline.

Turning Copilot’s Draft into a Real Data Flow

Let’s take the draft and turn it into something the operations team can actually use, keeping Copilot in the loop where it helps.

Step 1: Lock down the trigger and attachment handling

After Copilot drafts the flow, manually adjust:

1. Trigger

   • Use When a new email arrives in a shared mailbox (V2).
   • Set:
     • Original mailbox address: the shared mailbox.
     • Folder: Feedback.

2. Filter on CSV attachments

   • Add a Condition:
     • If Has Attachments is true AND any attachment name ends with .csv.

3. Save attachments to SharePoint

   • Inside the If yes branch, add an Apply to each over Attachments.
   • In the loop, use Create file (SharePoint):
     • Site address: your site.
     • Folder path: /CustomerFeedback/Incoming.
     • File name: attachments Name.
     • File content: attachments ContentBytes.

Copilot usually gets most of this, but verify the dynamic content for attachments — this is a common source of subtle bugs.

Step 2: Parse CSV without fighting the platform

There is no first-party “Parse CSV” action in standard Power Automate as of late 2026. You have a few options:

• Use a custom connector or Azure Function.
• Use an Office Script on the Excel file.
• Use native expressions and loops.

For a simple, tabular CSV with consistent commas and headers, you can stay inside Power Automate.

A pragmatic pattern:

1. After Create file, add Get file content (SharePoint) for the newly created CSV.
2. Use a Compose action with an expression to split into lines:

split(outputs('Get_file_content')?['body'], '\n')

3. Add an Apply to each over the lines, skipping the header:

• Use a condition inside the loop to skip the first line.
• For each line, split by comma:

split(items('Apply_to_each_line'), ',')

4. Map the resulting array elements to Excel columns in Add a row into a table.

This is crude but explicit. Copilot may suggest something similar, but it commonly:

• Misses the header row handling.
• Doesn’t handle empty lines.
• Doesn’t guard against malformed rows.

For anything more complex (escaping, semicolons, inconsistent columns), it’s safer to offload parsing to a script or API instead of trying to coax Copilot into writing robust expressions.

Step 3: Append to Excel safely

With rows parsed, configure the Excel action manually:

• Use Add a row into a table (Excel Online (Business)).
• Point to:
  • Location: SharePoint site.
  • Document library: the one holding CustomerFeedback.xlsx.
  • File: CustomerFeedback.xlsx.
  • Table: FeedbackTable.

Inside the Apply to each row loop, map array elements from the split line to table columns.

Example mapping (conceptual):

• TicketId → split(items('Apply_to_each_line'), ',')[0]
• CustomerEmail → index 1
• FeedbackText → index 2
• ReceivedOn → index 3

Copilot can help generate these expressions when asked directly (e.g. “Write an expression to get the first column from the CSV line”), but you still need to validate each mapping and ensure the column names match the table.

Step 4: Mark imported rows and archive attachments

To mark imported rows with ImportedOn:

• Add a column ImportedOn to FeedbackTable in Excel.
• In the Add a row into a table action, set ImportedOn to utcNow() via an expression.

To archive attachments:

• After the Apply to each attachment loop completes, add a Move file (SharePoint) action for each file.
• Alternatively, move the file inside the loop right after successful import.

Copilot usually suggests a Move file step, but you decide the placement depending on whether you want a file moved even if import fails.

Where Copilot Helped, and Where It Got in the Way

Looking back at the scenario, here’s a practical assessment.

Useful Copilot contributions

• Quick skeleton:
  • Correct trigger.
  • Reasonable attachment handling structure.
  • Right family of connectors.
• Minor productivity gains:
  • Auto-filling site addresses and library paths once you select them.
  • Generating simple expressions when prompted.
  • Explaining what a given action does in plain language.

Pain points for data-handling flows

• No end-to-end CSV support: You still need to design parsing and error handling.
• No awareness of data quality: Copilot doesn’t add guards for malformed rows or duplicates.
• Limited connector nuance: It doesn’t factor in Excel table limits, concurrency, or file locking issues.

For the operations team, Copilot saves setup time but doesn’t remove the need for a practitioner who understands the underlying connectors and data constraints.

Practical Patterns for Using Copilot on Data Flows

If you’re already comfortable with Power Automate, you can get real value from Copilot by using it deliberately instead of expecting magic.

Use Copilot for

• Drafting the first version of simple event-driven flows.
• Discovering possible actions when you’re not sure which connector supports a capability.
• Generating or explaining expressions for basic transformations.
• Refactoring flows (e.g. “add a step to log failures to a SharePoint list”).

Don’t rely on Copilot for

• Designing data models or table structures.
• Implementing non-trivial parsing and transformation logic.
• Ensuring idempotency, deduplication, and robust error handling.
• Optimising flows for capacity, performance, or concurrency.

Treat Copilot as a junior assistant who knows the catalogue of actions and can wire them together, but doesn’t understand your data domain or operational constraints.

One Takeaway: Let Copilot Start, But You Finish

For the question “Can Copilot build a data flow for you?” the honest answer, as of late 2026, is: it can build a usable starting point for simple event → action flows, but you still own the data logic.

For the operations team’s monthly feedback import, Copilot:

• Reduced the time to get a first draft from an hour to minutes.
• Still required a practitioner to design CSV parsing, Excel mapping, and archiving behaviour.

The practical takeaway: use Copilot to get from zero to a rough draft, then switch to deliberate, manual design for anything involving data structures, transformations, or reliability. That balance gives you speed without sacrificing control.