Skip to content
Tutorials Center
My learning

Topics

Lesson 33 of 38 ยท Governance and Performance

Delegation and Performance Tuning

Understand Power Apps delegation, the 500/2000 row data limit, delegable functions, and tuning tips: Concurrent, caching, fewer controls, lazy loading and gallery design.

An app that works with 50 test rows and fails quietly with 50,000 real ones is a classic Power Apps lesson. The cause is usually delegation. The second most common complaint, slow screens, comes from loading too much, too early. This lesson covers both.

What is delegation?

When you write Filter(Orders, Status = "Open"), Power Apps can do one of two things:

  • Delegate the work: send the condition to the data source (Dataverse, SQL Server), which filters and returns only the matching rows.
  • Download and filter locally: fetch rows into the app and filter them on the device.

Local processing only sees a limited number of rows: the data row limit, 500 by default and adjustable up to 2000 in Settings, General, Data row limit. If the table has 10,000 rows and the function is not delegable, the formula runs on the first 500 (or 2000) and silently ignores the rest. The editor warns with a blue dotted underline and the message "Delegation warning".

Delegation depends on the data source and the function. Dataverse and SQL Server delegate a lot (Filter, Sort, SortByColumns, Search in some forms, LookUp, Sum, Average, Min, Max, CountRows, comparison operators, StartsWith, in on some types). SharePoint and Excel delegate much less. Functions like Left, Mid, Len or Lower applied to a column inside a filter often cannot be delegated, nor can Distinct or GroupBy. Always check the official delegation list for your data source, because it changes.

Delegation in one slide

Delegated The source does the work
Not delegated App fetches first 500-2000 rows
Warning Blue dotted underline

Missing rows give wrong answers silently.

1 / 2

Seeing the silent truncation: a stand-in

This stand-in shows why a non-delegable filter gives a wrong answer on a big table. It limits the "downloaded" rows to a data row limit, like the app does.

JS Stand-in: delegation and the data row limit

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The delegated result is 100; the local one sees only the open orders among the first 500 rows. No error is shown at run time; only the editor warning and your tests can catch it.

How to fix a delegation warning

  • Rewrite the formula with a delegable form: Filter(Orders, StartsWith(Customer, txtSearch.Text)) instead of a Search on an unsupported column.
  • Add a column that stores the computed value (a Dataverse calculated or formula column) so the filter compares a plain column.
  • Push work into the source: a SQL view, a Dataverse view, or a flow that returns the result.
  • Reduce the data first with a delegable filter, then use non-delegable functions on the smaller result.
  • Raise the row limit only when the filtered set is known to stay below 2000.

Loading faster

  1. Use Concurrent to start independent loads at the same time:
TEXT
Concurrent(
    ClearCollect(colCustomers, Customers),
    ClearCollect(colProducts, Products)
)
  1. Load on demand. Put heavy ClearCollect calls on the screen where they are needed, not in App.OnStart. Prefer App.StartScreen and named formulas for lightweight values.
  2. Cache static lists (statuses, countries) in a collection once per session.
  3. Reduce controls per screen. Hundreds of controls slow rendering; use galleries with templates and hide rarely used sections on other screens.
  4. Avoid per-row lookups in galleries. A LookUp inside each gallery item triggers one call per row. Use a relationship column, AddColumns with one preloaded collection, or a Dataverse expand.
  5. Limit images and attachments. Store thumbnails, not full-size pictures.
  6. Use With/named formulas to avoid repeating the same expensive calculation.

Timing a load: a stand-in

Concurrent runs independent calls together, so the total time is the slowest call, not the sum. This stand-in makes the difference visible.

JS Stand-in: sequential versus concurrent loading

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Measuring

Use the Monitor tool (Monitor and Testing) to see each network call and its duration, and the app's Performance insights (in the maker portal, Apps, your app, Analytics) for load time and errors. Measure before changing anything, change one thing at a time and measure again.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What happens when a function in a Filter cannot be delegated?

    Only the limited local set is processed, and the rest of the rows are silently ignored.
  2. 2. How does the editor warn about delegation?

    The formula bar underlines the non-delegable part in blue.
  3. 3. What does Concurrent do?

    It starts independent formulas together, so total time approaches that of the slowest.
  4. 4. Why avoid LookUp inside every gallery row?

    Per-row lookups multiply network calls and slow the screen.

Summary

  • Delegation sends filtering to the source; non-delegable formulas work only on the first 500 to 2000 rows.
  • Fix warnings by rewriting formulas, adding helper columns or pushing work to the source.
  • Speed up apps with Concurrent, on-demand loading, caching and fewer controls.
  • Measure with Monitor and Analytics before and after.

Next: Monitor, Testing and Troubleshooting