A canvas screen that works fine with a few hundred records either returns incomplete results or sits empty for seconds once the list reaches a few thousand records. The user calls saying “the request I’m looking for isn’t in the system”; the record is there, the app has simply never seen it. The cause almost always turns up in two places: non-delegated queries and data pulled unnecessarily at startup. Below, in the order we use in the field, we explain how to read a delegation warning in an existing Power Apps app, how to rewrite the query and how to measure performance with Monitor.
What delegation is and why it matters
Delegation means a Power Fx query (filtering, sorting, searching) runs in the data source itself. When a query is delegated, Power Apps tells the source “give me the records matching this condition, in this order”; the filtering is done in SharePoint, Dataverse or SQL Server, and only pages of results come to the app. The gallery fetches these pages as the user scrolls.
If the query can’t be delegated, the behavior changes: Power Apps downloads only the first N records from the source and does the rest on the device. This N is the data row limit in the app settings. If you see a yellow triangle in the formula bar and a blue line under the formula, Power Apps is telling you clearly: this query isn’t going fully to the source. Passing over the warning because it’s “yellow, not red” is the most expensive mistake.
In a low-code app, choosing a delegable source isn’t enough on its own. Delegation depends on the combination of source + function + operator + column type. Excel tables and collections are local sources; the concept of delegation doesn’t exist there, and all the data comes to the device. SharePoint, Dataverse and SQL Server are delegable sources, but each supports a different set of functions. The same formula works in one and not in another.
The delegation limit and silent data loss
The data row limit is 500 by default; it can be raised to at most 2,000 under Settings > General > Data row limit. This is the “fix” we see most often in the field: setting the value to 2,000 and forgetting the warning. It doesn’t solve the problem; it only postpones the day it surfaces. The real risk is that there’s no error message. The app works. The result is incomplete.
A typical scenario: in a SharePoint “Requests” list with 6,000 records, the search box filters with Search(). Since Search isn’t delegated for SharePoint, Power Apps takes the first 500 records and searches among them. The user can’t find an old request. With counters the situation is sneakier: an expression such as CountRows(Filter(Requests, Status.Value = "Open")) may not be delegated depending on the source, and it produces a wrong but plausible-looking number on the dashboard. A wrong number is more dangerous than a missing one; nobody questions it.
You can also catch the warning at the review stage: the App checker in Power Apps Studio collects delegation warnings in a single list. Putting “zero delegation warnings in App checker, or deliberately accepted” on the pre-release checklist is the cheapest way to keep the problem out of production. A five-minute check prevents weeks of “data is disappearing” complaints.
Delegable query patterns
Supported functions vary by source, and Microsoft expands these lists over time; the final reference is the delegation table in each connector’s documentation. The table below is a starting point for the patterns we trip over most often in the field, not a list to memorize.
| Pattern | SharePoint | Dataverse | Alternative |
|---|---|---|---|
Filter + = |
Delegated | Delegated | — |
StartsWith |
Delegated | Delegated | Prefer for search |
Search, EndsWith |
Not delegated | Check the connector documentation | StartsWith or a separate search column |
in (substring) |
Not delegated | Check the connector documentation | = on a choice/lookup column |
Sum, Average |
Not delegated | Delegated (with row limitations) | Calculate the total in Power Automate or on the server |
<, > on the ID column |
Only = is delegated |
— | Use a date or number column |
Understanding the rule is more useful than memorizing the list. For a condition to be delegable, the row-dependent part must be evaluable on the source side. Row-independent expressions (Today(), a variable, the selected value of a dropdown) are calculated first on the Power Apps side and sent as constants; they don’t cause problems. The problem is putting the column value into a non-delegable function: Filter(Requests, Year(Created) = 2026) isn’t delegated, while the same condition written as a date range is. Don’t put the column inside a function.
// Not delegated: the column value goes inside Year()
Filter(Requests, Year(Created) = 2026)
// Delegated: the fixed range is calculated first
With(
{ startDate: Date(2026, 1, 1), endDate: Date(2027, 1, 1) },
Filter(Requests, Created >= startDate && Created < endDate)
)
// Search: StartsWith instead of Search (SharePoint)
Filter(
Requests,
StartsWith(Title, txtSearch.Text),
Status.Value = drpStatus.Selected.Value
)
On the SharePoint side, there’s a second limit in the list itself. In a list exceeding the list view threshold (5,000 items), a delegated filter applied to a non-indexed column can throw an error or return unexpected results. That’s why indexing the filtered and sorted columns in SharePoint is part of app design, not a later tweak; we covered column and content type decisions in the SharePoint metadata and content type design guide. If the source keeps producing delegation problems, the problem isn’t the formula but the choice of source; we compared this decision in the Dataverse or SharePoint list article.
Reducing screen load time
Delegation is about correct results; load time is about when and how much data is pulled. In slow-loading apps, the first place to look is App.OnStart. Most contain a long chain of ClearCollect calls. Each call waits for the previous one, and the user waits for all of them to finish without needing any of them.
Parallel loading: Concurrent
Independent loads are run in parallel with Concurrent(); the total time approaches that of the slowest call. There’s one condition: the execution order of formulas inside Concurrent isn’t guaranteed. Don’t use the result of one in another.
Concurrent(
ClearCollect(colDepartments, Departments),
ClearCollect(colCategories, Categories),
Set(gblUser, Office365Users.MyProfileV2())
)
Named formulas instead of OnStart
Named formulas defined in App.Formulas are declarative: the value is calculated when first used and updated as the data it depends on changes. Using named formulas instead of Set() for the user’s email, role information and fixed lists lightens startup and reduces “why isn’t the variable up to date” type errors. To set the first screen, use the App.StartScreen property instead of Navigate in OnStart; Power Apps can prepare the first screen without waiting for OnStart to finish.
// App.Formulas
UserEmail = Lower(User().Email);
IsManager = !IsBlank(LookUp(Managers, Email = UserEmail));
OpenStatuses = ["New", "In progress", "On hold"];
A collection is a cache, not a source
Small reference tables that rarely change (departments, locations, categories) can be loaded into collections. Copying thousands of rows of transaction data into a collection, however, creates two problems: the copy hits the data row limit, and the gallery can no longer benefit from the source’s paging. For transaction data, bind the gallery directly to a delegated Filter. It’s both faster and more correct.
Load at the screen and control level
- Running
LookUpon every row of a gallery means as many separate requests as there are rows. Keep related data at the source (a relationship in Dataverse, a lookup column in SharePoint) or read the small reference table from a collection. - The
Itemsproperties of invisible controls can also be evaluated. Move rarely used tabs to a separate screen. - A screen referencing a control on another screen directly can cause that screen to load as well. Carry data between screens with a variable or the
Navigatecontext parameter. - Large images embedded in the app bloat the package size; compress images and, if possible, read them from a SharePoint library.
Measuring performance with Monitor
Optimization isn’t done by guesswork. For measurement, Advanced tools > Monitor is used in Power Apps Studio. Monitor shows every network request the app makes, every formula evaluation and its duration as a list of events. A published app can also be monitored; that way you see the behavior in the user’s real environment by joining a session with them.
This is the measurement order we follow:
- Open Monitor and start the app from scratch; record all requests at startup.
- Sort the events by duration. The longest requests and many consecutive requests to the same source are the first targets.
- Look at the number of rows returned in each request’s details. If the number of rows returned is exactly equal to the data row limit (for example 500 or 2,000), you’ve found a non-delegated query; delegated queries come in smaller pages independent of the limit.
- Record operations the user does every day, such as scrolling the gallery and submitting forms, separately.
- After a change, measure the same scenario again and compare the timings.
A measurement made on a developer’s computer on a fast office network is misleading. If field users of corporate business applications connect over mobile data or a crowded Wi-Fi, make at least one measurement under those conditions. On a slow line, load time is determined mostly by the number of requests. Bandwidth comes second.
Canvas app performance checklist
- No delegation warnings in App checker; any remaining ones were deliberately accepted and documented for small tables that won’t grow.
- Testing was done with a low data row limit; no queries producing incomplete results remain.
- Conditions using
Search,inand putting the column value into a function were replaced with delegable equivalents. - Filtered and sorted columns in SharePoint were indexed.
OnStartcontains only loads that are really necessary; independent loads run in parallel withConcurrent.- Fixed definitions are in
App.Formulas; the start screen is set withApp.StartScreen. - There are no
LookUpcalls or heavy calculations in gallery rows. - Startup and daily operations were measured with Monitor; the results were added to the release notes.
If the app lives in more than one environment (development, test, production), run these checks in the test environment with a realistic data volume; a 50-record test list will never reveal a delegation error. We explained environment separation in the Power Platform environment strategy article. For improving existing apps and designing apps at enterprise scale, see our business applications with Power Apps page. For current delegation tables by function, Microsoft’s Power Apps delegation overview document should be the reference.
Frequently asked questions
Does raising the data row limit to 2,000 solve the delegation problem?
No. Raising the limit only increases the number of records a non-delegated query processes. When the source exceeds 2,000 records, the incomplete results problem comes right back, and since more data is downloaded, loading is slower too. The permanent fix is to rewrite the query in a delegable form or move to a suitable source.
Do delegation warnings always need to be fixed?
If a table will permanently stay below the data row limit, for example a 30-row location list, the warning can be deliberately accepted. Document this decision. For transaction tables that may grow, always fix the warning.
Are there delegation problems with data loaded into a collection?
A collection is a local source; all its data is on the device and queries run completely. The problem arises when filling the collection: a collection filled by a non-delegated query contains at most as many records as the data row limit. That’s why collections are for small reference data.
Can Monitor be used on a published app?
Yes. A Monitor session is started from the app’s details in the Power Apps portal, and the published app is run connected to this session. The requests and timings in the user’s real environment then become visible. Since user data will also be visible, run the session with the user’s consent.