Here are ten common performance killers in Power Apps and practical ways to avoid them.

1. Too Many Controls on a Single Screen

Every control in a Power App—buttons, labels, icons, images, etc.—requires rendering and memory. When too many controls are placed on a single screen, the app must process all of them, leading to slow screen loading times, particularly on mobile devices.

How to Avoid:

• Try to stay under 500 total controls per app.
• Break large screens into multiple smaller screens.
• Use reusable components to reduce repetition and complexity.
• Hide controls conditionally and load only what's needed.

2. Redundant or Unbatched Data Calls

Calling the same data source repeatedly across controls or screens can result in unnecessary load times. Multiple unbatched calls to different data sources increase network latency and slow down the app, especially when users have slow internet connections.

How to Avoid:

• Use the Concurrent() function to load multiple data sources at once in parallel.
• Cache data using ClearCollect() during app startup (OnStart or App.OnStart).
• Use local variables (Set or UpdateContext) for values that don't need to be recalculated repeatedly.

3. Non-Delegable Queries

Delegation is the ability of Power Apps to push data processing to the data source (like SharePoint, Dataverse, or SQL). When using functions that are not delegable, Power Apps only retrieves the first 500–2000 records (depending on settings) and processes the rest locally, which can lead to incomplete data and poor performance.

How to Avoid:

• Understand which functions and data sources support delegation. Use delegable alternatives whenever possible.
• Limit use of functions like Len(), Sum(), Search() or Sort() directly on data sources.
• Use server-side calculated columns or views if needed.

4. Loading Entire Data Sets Without Filtering

Fetching entire lists or tables into the app, especially without filters, is a common issue that results in slow loading times and potential delegation problems.

How to Avoid:

• Always use filters on galleries and dropdowns.
• Limit queries to only what the user needs (e.g., Filter(Projects, AssignedTo = User().Email)).
• For large data sets, consider pagination, views, or virtual tables in Dataverse.

5. Heavy Calculations in Control Properties

Placing complex or repeated formulas directly inside control properties (like Text, Visible, or Fill) causes recalculations every time the screen updates, leading to noticeable lag.

How to Avoid:

• Use variables to store computed values using Set() or UpdateContext().
• Move calculations out of controls and into screen events like OnVisible or OnStart.
• Avoid nesting multiple functions when not necessary.

6. Inefficient Galleries

Galleries are powerful but can become performance bottlenecks if not used carefully. Nesting galleries, placing too many controls inside a gallery, or using complex expressions per row increases rendering load and slows scrolling.

How to Avoid:

• Keep the number of controls inside a gallery to a minimum.
• Avoid nested galleries unless absolutely necessary.
• Avoid using ThisItem with calculated expressions in every row—pre-calculate with collections or variables.

7. Using Too Many Data Sources

Each data source connection (SharePoint, SQL, Outlook, etc.) adds overhead. More sources mean more chances for failure and more performance impact.

How to Avoid:

• Consolidate data into fewer sources when possible.
• Avoid connecting to Excel files stored in OneDrive—they are slow and prone to issues.
• Prefer Dataverse or SharePoint for structured and scalable data storage.

8. Misuse of Collections

Collections are helpful for storing and manipulating data locally, especially in offline scenarios. However, creating large collections unnecessarily or repeatedly refreshing them can consume memory and delay app startup.

How to Avoid:

• Only use ClearCollect() when truly needed.
• Avoid collecting entire data sources.
• Use Collect() or Patch() selectively, and avoid duplicating the same data in multiple collections.

9. Excessive LookUps and Defaults

Functions like LookUp() and Defaults() can trigger multiple data calls if used directly in forms or repeated multiple times across controls. This slows down screen transitions and form responsiveness.

How to Avoid:

• Cache frequently used records in a variable when navigating (Navigate(Screen1, {}, {SelectedItem: ThisItem})).
• Use Patch() with a known record instead of Defaults() where possible.
• Load data in OnVisible events and bind it to controls via variables.

10. Loading Everything Upfront

Loading all controls, data, and logic when the app starts leads to long startup times, especially for larger apps. It’s unnecessary if the user doesn’t immediately need all screens and data.

How to Avoid:

• Load only critical data on app startup.
• Use OnVisible or OnSelect to load data conditionally.
• Apply lazy loading techniques to load screens and data only when required.

Summary and Final Tips

A high-performing Power App is more than just functional—it must also be responsive, scalable, and user-friendly. Here are a few more tips to boost performance:

• Use the Monitor Tool to inspect and debug performance issues in real-time.
• Compress images and videos before uploading.
• Use modern controls, which are optimized for better rendering.
• Limit the use of timers, auto-start media, and animations.
• Avoid using ResetForm() unnecessarily—it triggers a re-render of the whole form.

By proactively avoiding these ten performance killers and applying best practices, you’ll be well on your way to building Power Apps that users love to use.

Source URL: 10 Performance Killers in Power Apps (and How to Avoid Them)