When a customer asked us to enable large file uploads to SharePoint from a Canvas App, but without any premium licenses, we thought: “Sure, that will be fine.”

Spoiler: it was not fine.

Over the course of several days, we explored every possible route inside the Power Platform. We hit limitations that were not documented, connectors that silently corrupted files, and platform behaviors that made chunked uploads nearly impossible.

This blog walks through the full journey – the good, the bad, and the ugly – and shows why Power Automate simply is not the right tool for chunked uploads, what does work, and the final solution that stays fully within the platform and requires zero premium licenses.

Why Uploading Big Files Should Be Easy… but Is Not

Uploading files to SharePoint sounds simple. But once you exceed around 50–70 MB, all the “normal” approaches break down.

To solve this, we even built a PCF component that chunked the file inside the browser, returning the chunk data back to the Canvas App, which would then pass it into Power Automate.

In theory, this should bypass all size limitations – as long as Power Automate can handle the binary chunks.

It turned out: it cannot.

Here is what we learned.

1. Native SharePoint Connector: Works… Until It Does Not

The standard SharePoint connector works well for small files.

But above roughly 60–70 MB, uploads begin to fail:

• Timeouts
• Crashes
• Corrupted files
• Flows that simply stop mid-upload

This approach hit a hard ceiling almost immediately.

2. SharePoint Connector HTTP Action: Looked Promising, But Did Not Work

Because we had built a PCF component that chunked the file and returned binary chunks, the idea was simple:

1. PCF splits the large file into multiple binary chunks
2. Canvas App calls Power Automate for each chunk
3. Power Automate uses the SharePoint REST API (via the built-in SharePoint HTTP action)
4. The REST API writes each chunk in sequence to SharePoint

This would fully bypass the limits of the regular connector.

However, this approach failed because the SharePoint HTTP action cannot accept binary content correctly.

It corrupts binary data when sending it.

So even with perfectly valid binary chunks from the PCF, the moment Power Automate tries to relay them to SharePoint REST, the data becomes invalid.

Result:

• Every uploaded file is corrupted
• Chunked uploads via this method are effectively impossible

This limitation kills the approach entirely.

3. Using Microsoft Graph with the HTTP Connector: Theoretical Winner, Practical Disaster

This one was especially frustrating.

The customer was allowed to use a Power Automate premium license, which meant:

• We were allowed to use the HTTP connector
• We were allowed to call Microsoft Graph
• We were allowed to perform chunked uploads through the official Graph API

On paper, this should have been the winning approach.

Combined with our PCF chunking logic, the architecture should have been perfect:

1. PCF chunks the file
2. Canvas App sends chunk metadata and the binary chunk to Power Automate
3. Power Automate sends each chunk to Microsoft Graph using the HTTP connector
4. Graph assembles the full file in SharePoint

We tested this thoroughly.
In Postman, it worked flawlessly.
In Power Automate, it failed every single time.

The reason: the HTTP connector strips critical headers.

Specifically:

• Content-Range
• Content-Length
• Most other Content-* headers

These headers are required for Graph chunked uploads.
Once again, read the docs first.. 🙂 https://learn.microsoft.com/en-us/azure/connectors/connectors-native-http?tabs=standard#omitted-http-headers

Without them, Graph returns errors, and the upload process breaks immediately.

Because Power Automate removes these headers, there is no real workaround.

So even though:

• We had PCF chunking
• We had premium licensing
• We used the correct Graph API
• We followed Microsoft’s documentation

it still did not work.

This was the final confirmation:
Power Automate is not a reliable platform for chunked upload flows.

4. PCF Chunked Upload Alone: Technically Beautiful, Licensing Nightmare

The PCF chunking logic worked perfectly on its own.

However, using the PCF upload directly (bypassing Power Automate) would require:

• Calling SharePoint or Graph directly from the PCF
• Which reintroduces premium licensing requirements

A Canvas App that uses a PCF becomes a premium app, meaning all users would require premium licenses.

Since the customer did not want that, the PCF-only approach was not an option.

5. The Unexpected Winner: Groups 365 Connector

After removing every other option, we ended up with the Groups 365 connector – and surprisingly, it did exactly what we needed.

Why the Groups 365 connector turned out to be the best option:

• Supports larger files (up to approximately 250 MB)
• No premium license required
• Binary data is handled correctly
• Much more stable than the normal SharePoint connector
• Works cleanly inside Power Automate
• Integrates well with Canvas Apps

In practice, there is one important caveat:

• The effective maximum file size you can upload depends heavily on the user’s upload speed.
• On slower connections (for example, below about 20 Mbps upload), we saw timeouts or failures when trying to upload files larger than roughly 100 MB.

So while the connector itself supports up to around 250 MB, you should set realistic expectations:

• Fast, stable connections can approach that upper limit
• Slower or unreliable connections may require you to keep files closer to 50–100 MB to avoid timeouts

Even with that limitation, this became the only fully stable, production-ready solution that:

• Stays inside Power Platform
• Requires no premium licensing
• Avoids binary corruption
• Handles significantly bigger files than the standard SharePoint connector

Here you can find a example on how to use this. All credits to Laura Rogers for providing this solution on here blog: https://www.iwmentor.com/pages/blog/power-apps-file-upload-files-to-sharepoint-libraries-no-flow. You can find instructions on how to get the siteid & drive id in here blog.

With(
    {
        siteId: "YOUR_SITE_ID_HERE",
        driveId: "YOUR_DRIVE_ID_HERE",
        folderName: "YOUR_FOLDER_NAME_HERE"
    },
    Office365Groups.HttpRequest(
        "https://graph.microsoft.com/v1.0/sites/" & siteId &
            "/drives/" & driveId &
            "/root:/" & folderName & "/" & First(Attachments).Name & ":/content",
        "PUT",
        First(Attachments).Value
    )
)

Why Power Automate Is Not a Chunked Upload Platform

Our conclusion after all of this:

Power Automate is not designed for chunked file uploads.

It lacks:

• Safe, unmodified binary pass-through
• Support for required REST and Graph upload headers
• Stability for long-running upload processes
• Streaming support
• True developer control over HTTP behavior

If you must achieve chunked uploads, your options are:

• PCF direct upload (premium)
• Azure Functions (outside Power Platform)
• Custom app or external service
• Groups 365 as a non-premium alternative up to about 250 MB (with practical limits depending on network speed)

I Wish I Had Read This Before Starting

Looking back, this was one of those projects where having the right information upfront would have saved a lot of time, energy, and grey hairs.
If I had come across a clear explanation like this blog post before diving into all the dead ends, I would have avoided days of testing and reverse-engineering connector limitations that were never documented anywhere.

If you are starting a similar journey: learn from this experience, and save yourself the frustration.

Conclusion: The Realistic, Working, Non-Premium Solution

If you need to upload large files to SharePoint from a Canvas App, without premium licenses for every user, your options become very limited.

After extensive testing, here is the final verdict:

Final recommendation:

Use the Groups 365 connector for uploading larger files into SharePoint without premium licensing. On good connections, you can approach the theoretical limit of around 250 MB. On slower connections (for example, under 20 Mbps upload), design for safer limits around 50–100 MB to avoid timeouts.

This is currently the most practical, fully in-platform solution, as long as you take user network speeds into account when designing your process and setting expectations.

Credits

The final solution described in this blog post is based on the approach originally shared by Laura Rogers on her blog at IW Mentor. Her article provided the key insight that the Office 365 Groups connector can upload files directly to SharePoint without requiring Power Automate. Full credit to her for discovering and publishing this method.

Source: https://www.iwmentor.com/pages/blog/power-apps-file-upload-files-to-sharepoint-libraries-no-flow