Power Apps Performance: 50 tips for fast canvas apps.

Canvas apps can connect to a great many data sources. For enterprise applications with high performance requirements, Microsoft recommends Dataverse as the data source.

Before building the app, assess the demands it will need to meet: How many people will use it after publication? How many records will be created, read, changed, and deleted? What type of data interaction will be most common? Where will people access the app, and on which devices?

• Microsoft Learn: Create high-performance canvas apps (overview) (opens in a new tab)

The region of the Power Platform environment, and therefore the distance between data source and device, affects the performance of a canvas app.

Power Apps delivers the app's static content via a Microsoft Azure content delivery network (CDN). Data, however, always comes directly from the data source. A large distance therefore has an effect on many levels: higher latency, lower throughput, less bandwidth, and, in the worst case, packet loss.

An inadequately or incorrectly configured local network slows down canvas apps, often without being noticeable at first glance.

• Microsoft Learn: Required services and addresses for Power Apps (opens in a new tab)

The Power Platform limits the number of requests a person can make per day via Power Automate, Power Apps, Microsoft Copilot Studio (formerly Power Virtual Agents), and Dynamics 365 applications. This is how Microsoft ensures service quality and availability.

How high the limits are depends on the license. People who use the Power Platform only through the rights included in Microsoft 365 have significantly lower limits than people with their own Power Automate or Power Apps license (as of October 2026: 6,000 instead of 40,000 requests per 24 hours).

• Microsoft Learn: Request limits and allocations (opens in a new tab)
• Microsoft Learn: Limits and configuration in Power Automate (opens in a new tab)

The same app can behave very differently depending on the device, especially when large amounts of data are loaded on Windows, iOS, or Android.

The reason: each platform limits network requests differently, for example the number of requests allowed at the same time. This directly affects the loading time of large amounts of data.

On mobile devices in particular, a canvas app suffers when other apps in the background put load on the cellular network or Wi-Fi. The additional data traffic also increases memory usage on the device.

With unsupported or outdated browsers, performance problems occur more frequently in canvas apps.

• Microsoft Learn: Supported browsers for Power Apps (opens in a new tab)

Installed extensions and add-ons can noticeably slow down the execution of a canvas app.

How fast an app loads depends heavily on how many columns it retrieves. Every column that is neither displayed nor used in formulas creates additional data traffic and takes up memory on the device.

This particularly affects mobile devices and computers with older processors, little memory, or a weak connection.

Out-of-memory exceptions are the most common cause when a canvas app crashes or freezes on certain devices. The JavaScript memory (heap) reaches its limit because extensive scripts on the device join, filter, sort, or group data.

• Microsoft Learn: Fix memory problems (Microsoft Edge DevTools) (opens in a new tab)

Delegable functions shift processing to the data source. The device receives only the result and has to do much less work.

Where delegation is not possible, the app processes only the first records up to the data row limit for non-delegable queries. It is 500 by default and can be changed in the app settings under General. Since October 2026, Microsoft's English documentation has stated 10,000 as the maximum, while the German documentation still states 2,000. In my test in November 2026, the highest value I could set was 2,000. However, higher values can worsen performance. Not to be confused with the list view threshold in SharePoint (5,000 items), which is a separate limit of the list.

// Delegable: the data source filters, the device receives only the result
Filter(Orders, Status = "Open" && OrderDate >= DateAdd(Today(), -30))

• Microsoft Learn: Understand delegation in a canvas app (opens in a new tab)
• Microsoft Learn: Optimized query patterns (opens in a new tab)

The structure of an app also affects its performance. A typical example: the app first loads large amounts of data onto the device and then reduces it across several screens with filters, sorting, or grouping. A long formula in OnStart can also trigger many unnecessary data calls.

• Microsoft Learn: Monitor in Power Apps (opens in a new tab)

Pagination splits large amounts of data into smaller blocks instead of displaying everything at once. This reduces memory usage and load on the data source, shortens loading times, and makes the app more responsive.

At the same time, lists become clearer, because nobody is overwhelmed by a flood of entries.

Efficient data queries are crucial for every canvas app. Excessive or poorly built queries lengthen loading times and waste resources.

Every control on a screen increases memory usage as soon as the screen is loaded. Lean screens render faster and need less memory.

• Microsoft Learn: Gallery control (opens in a new tab)

Components are reusable building blocks for canvas apps. With them, you build your own controls that you use on all screens. They can contain custom properties and even complex logic.

• Microsoft Learn: Create components for canvas apps (opens in a new tab)

The Text property of a text input changes with every keystroke. If a query depends on it, for example a search in a gallery, every letter starts a new data call.

// Classic text input txtSearch, property DelayOutput
true

// Gallery galCustomers, property Items
Search(Customers, txtSearch.Text, Name)

• Microsoft Learn: Text input control (classic) (opens in a new tab)
• Microsoft Learn: Modern text input (opens in a new tab)

If a formula references controls on other screens, Power Apps must keep those screens in memory, even if they are not currently displayed. This can significantly degrade performance.

// Screen scrCustomers: remember the selection and navigate
Set(gblCustomer, galCustomers.Selected);
Navigate(scrCustomerDetail)

// Screen scrCustomerDetail: variable instead of galCustomers.Selected
gblCustomer.Name

• Microsoft Learn: Set function (opens in a new tab)

If the "Debug published app" setting is turned on, the app runs more slowly.

• Microsoft Learn: Debug a published app (opens in a new tab)

The StartScreen property determines which screen appears first. Power Apps evaluates it once at startup. If it is empty, the first screen in the tree view appears.

// App, property StartScreen
If(IsBlank(Param("OrderId")), scrStart, scrOrder)

• Microsoft Learn: StartScreen property (opens in a new tab)

Data-heavy formulas in OnStart are among the most common mistakes when building canvas apps. They can significantly delay the app's startup and the content that depends on it. Only the data that is really needed to start the app should be retrieved here.

// Screen scrOrders, property OnVisible (instead of App.OnStart)
ClearCollect(colOpenOrders, Filter(Orders, Status = "Open"))

• Microsoft Learn: Fast app and page loads (opens in a new tab)

OnStart runs every time the app starts. Large amounts of data at this point therefore slow down every single startup.

// App, property Formulas (named formulas)
nfActiveCustomers = Filter(Customers, Active = true);
nfToday = Today();

• Microsoft Learn: Formulas property (named formulas) (opens in a new tab)
• Microsoft Learn: Fast app and page loads (opens in a new tab)

Large or uncompressed images not only degrade performance, they also noticeably delay rendering.

• Microsoft Learn: Image control (opens in a new tab)

Microsoft continuously develops the Power Platform. A canvas app benefits from this, but many improvements become available only when the app is republished.

Every recalculation of data or formulas costs processor time and memory. Repeated and superfluous recalculations slow down the app.

Global variables store values for the entire app. This is convenient, but every variable takes up memory and, if not managed properly, can lead to bottlenecks.

// Clear a variable that is no longer needed
Set(gblSelection, Blank())

• Microsoft Learn: Variables in canvas apps (opens in a new tab)

Long tasks such as extensive data queries should not make the user interface unresponsive. If the app remains usable during this time and provides feedback, it feels smooth and does not appear to freeze.

// Loading indicator with a context variable
UpdateContext({locLoading: true});
ClearCollect(colOrders, Filter(Orders, Status = "Open"));
UpdateContext({locLoading: false})

// Loading indicator, property Visible
locLoading

Caching means storing data temporarily so that access and calculation are faster. The usual method in Power Apps is collections: the app keeps data in memory and does not have to query the data source again.

• Microsoft Learn: Create and update a collection (opens in a new tab)

Mobile devices strictly limit memory. Collections are stored in the device's RAM. If too little memory remains, the operating system terminates the app and it crashes.

ClearCollect(
    colCustomers,
    ShowColumns(Filter(Customers, Active = true), Name, City, Phone)
)

• Microsoft Learn: Shaping tables: AddColumns, DropColumns, and ShowColumns (opens in a new tab)

ForAll with one Patch per record is slow with many records, because a separate write call goes to the data source for each record.

// Slow: one call per record
ForAll(colChanges As c,
    Patch(Orders, LookUp(Orders, ID = c.ID), {Status: c.Status})
)

// Faster: one Patch with a table
// (each row of colChanges contains the ID and the changed columns)
Patch(Orders, colChanges)

• Microsoft Learn: Create and update records in bulk (opens in a new tab)

Complex, nested formulas lengthen processing. Sometimes they are necessary, but they are hard to understand, hard to maintain, and make the app sluggish.

With(
    {net: Sum(colLineItems, Quantity * Price)},
    net * 1.19
)

At startup, an app often preloads several data sources. Usually, this happens sequentially in OnStart.

Concurrent(
    ClearCollect(colCustomers, Customers),
    ClearCollect(colProducts, Products),
    Set(gblMe, User())
)

• Microsoft Learn: Concurrent function (opens in a new tab)

Clear empties a collection; Collect adds records. ClearCollect does both in one step and is therefore faster than two separate calls.

// Two steps
Clear(colProducts); Collect(colProducts, Products)

// One step
ClearCollect(colProducts, Products)

• Microsoft Learn: Clear, Collect, and ClearCollect functions (opens in a new tab)

With the counting functions, you determine how many records meet a condition.

// Instead of
CountRows(Filter(Orders, Status = "Open"))

// better
CountIf(Orders, Status = "Open")

• Microsoft Learn: Count, CountIf, and CountRows functions (opens in a new tab)

UpdateContext creates context variables that temporarily hold a value, for example how often a button was clicked. A sequence of individual calls adds unnecessary overhead.

UpdateContext({locLoading: true, locError: "", locPage: 1})

• Microsoft Learn: UpdateContext function (opens in a new tab)
• Microsoft Learn: Variables in canvas apps (opens in a new tab)

SharePoint has dynamic column types such as Lookup, Person or Group, and Calculated. The more of them a list contains, the longer SharePoint takes to resolve them before the data goes to the app. This adds avoidable overhead in SharePoint.

Large images or attachments in SharePoint slow down retrieval on the device. This is because the matching records, up to the data row limit, come to the device with all queried columns, including those the app does not use at all.

• Microsoft Learn: Transfer small amounts of data (opens in a new tab)

OData queries to SharePoint depend heavily on the number of columns and of rows retrieved, limited by the data row limit for non-delegable queries. Fewer columns and a lower data row limit improve performance.

With Dataverse, data requests go directly to the environment, without the detour via Azure API Management. Nevertheless, an app can be slow if a lot of computation happens on the device, for example when filtering.

• Microsoft Learn: Data flow with Dataverse (opens in a new tab)

An app becomes slow if its queries trigger table scans in the database instead of an index seek.

// Index seek possible
Filter(Customers, StartsWith(Name, txtSearch.Text))

// Index or table scan
Filter(Customers, txtSearch.Text in Name)

Index keys are created in ascending order (ASC) by default. For an index on a single column, the direction does not matter; SQL Server also reads it backward. It becomes important for indexes on multiple columns when the app sorts in mixed order, for example by customer ascending and, within that, by date descending.

-- Query: newest orders first for each customer
CREATE INDEX IX_Orders_Customer_Date
    ON dbo.Orders (CustomerId ASC, OrderDate DESC);

Performance problems also arise on the server, for example through locks, waits, deadlocks, or query timeouts.

By default, a canvas app displays data via the database's tables or views. Retrieving all columns of a table slows down the response, especially with large data types such as NVARCHAR(MAX).

CREATE VIEW dbo.vwOpenOrders AS
SELECT ID, Number, Customer, OrderDate, Amount
FROM dbo.Orders
WHERE Status = N'Open';

A canvas app performs grouping and non-delegable filters on the device, using processor and memory. Depending on the data source and data volume, this takes noticeable time, and memory usage increases.

CREATE VIEW dbo.vwRevenueByCustomer AS
SELECT Customer, COUNT(*) AS Orders, SUM(Amount) AS Revenue
FROM dbo.Orders
GROUP BY Customer;

An on-premises data gateway can consist of several nodes. If just one of them is unreachable, requests to this node are not answered in time or end with an error message after a timeout.

• Microsoft Learn: On-premises data gateway in Power Apps (opens in a new tab)

The on-premises data gateway translates OData requests into database commands (DML) and needs to know the table schema to do so. If there is high network latency between gateway and database, every request costs additional time.

• Microsoft Learn: On-premises data gateway performance (opens in a new tab)

Unhandled errors lead to unexpected behavior, crashes, or even the loss of input. Robust error handling detects problems and responds appropriately, for example with an understandable message or a retry.

IfError(
    Patch(Orders, Defaults(Orders), {Title: txtTitle.Text}),
    Notify("Could not save: " & FirstError.Message, NotificationType.Error)
)

• Microsoft Learn: Error, IfError, and IsError functions (opens in a new tab)

Requirements change, data sources grow, and new features are added. All of this affects an app's performance, often gradually.

Regular performance tests uncover bottlenecks and inefficient processes. Tools such as Monitor and App checker in Power Apps help collect and analyze the data.

• Microsoft Learn: Monitor in Power Apps (opens in a new tab)

Testing is part of every modern development cycle, including for canvas apps. It safeguards the required quality and finds errors early, before they become noticeable in daily use. For small apps, manual tests are often sufficient. For complex apps, a testing tool is worthwhile.

• Microsoft Learn: Test Studio (opens in a new tab)

Fewer errors and crashes, lower costs, an edge over others, more efficient development, future-proofing, economical use of data, and a better image for your company: an optimized app pays off on many levels.

• All benefits at a glance