Performance Tuning in Power Apps: Reducing Load Times in Complex Apps

Audience: App makers, Power Apps developers, architects working with Canvas apps who want to reduce app startup times and improve perceived responsiveness.

Why Load Times Matter

Users expect apps to respond quickly. If the first screen takes too long to show up, frustration goes up, usage drops.  Complex apps, with many data sources, screens, formulas, and media, tend to accumulate performance debt — small inefficiencies that add up.  Optimizing load times improves user experience, lowers risk of crashes (especially on mobile), and often reduces backend cost or overhead (less data transferred, fewer unneeded calls).

Key Principles & Antipatterns

1. Before diving into tactics, it helps to understand some core principles and common mis‐steps:
2. Do work in the right place. Some operations are best done at app load (OnStart), others deferred (OnVisible, On demand).
3. Load only what’s needed initially. Don’t fetch data you won’t use until later screens.
4. Minimize network / connector calls. Each call has latency; many small calls are often worse than fewer bigger ones.
5. Balance client vs server work. Use delegation where possible: do filtering, sorting, aggregations at the data source rather than in the client/app.
6. Reduce control / UI complexity. Every control adds overhead (rendering, memory).

Antipatterns include:

1. Putting too much logic / data fetching in OnStart, causing long startup delays.
2. Repeated LookUps inside galleries or other repeating controls → N+1 problem.
3. Retrieving many columns or entire tables when only a few fields are used.
4. Including many hidden or unused screens/controls/resources.
5. Heavy embedded media or high resolution images that aren’t optimized.

Best Practices / Tactical Tips

Here are proven techniques to reduce load times, especially in large or complex apps.

1. Optimize Data Loading

1. Use delegation properly. Make sure filtering, searching, sorting is done at the server/data source level. If a formula isn’t delegable, Power Apps has to pull more data to the client which slows things down. (Microsoft Learn)
2. Explicit column selection. Only retrieve the fields (columns) you will actually use. Use ShowColumns or configure the data source settings so you don’t bring in every field by default. (Microsoft Learn)
3. Filter early. Don’t load full tables into collections if only a subset is needed initially. For example, only load recent records; load more on demand. (Rishan Digital)
4. Concurrent data fetching. Use  Concurrent()  to fetch multiple needed datasets in parallel instead of one after another, when starting the app or switching to a screen. (Matthew Devaney)

2. Streamline Startup / OnStart Logic

1. Minimize work in  App.OnStart . Only essential initialization and data fetching should happen here. Other logic can often be deferred. (Microsoft Learn)
2. Defer non‐critical data to later screens. Use screen’s  OnVisible  or component loading to pull in data only when needed. (Rishan Digital)
3. Lazy loading and paging. For galleries or lists, load initial subset (e.g. top N records), then load more as users scroll or navigate. Avoid loading massive datasets all at once. (Microsoft Learn)

3. Reduce UI and Control Overhead

1. Minimize # of screens and controls per screen. If a screen has too many controls, grouping, combining, or moving functionality to other screens can help. Use galleries/components cleverly. (Matthew Devaney)
2. Avoid referencing controls on other screens. When you do, even hidden screens need to be kept in memory, slowing navigation and startup. Instead, use variables to pass data. (Matthew Devaney)
3. Use DelayOutput for text inputs. If you have search boxes, typed filters etc., enabling  DelayOutput  reduces the load by waiting until user stops typing instead of sending a request on every keystroke. (Matthew Devaney)

4. Media, Assets, Images

1. Compress images / use appropriate formats. Avoid overly high resolution or large file size for images or icons that don’t need them. (Visual Path Blogs)
2. External vs embedded media. Consider hosting media assets in external storage (Azure Blob, SharePoint etc) and load on demand rather than embedding everything. (Visual Path Blogs)

5. Data Source & Backend Considerations

1. Choose the right data source. Some data sources are faster or more efficient for your use case. For example, Dataverse tends to perform better than Excel or certain large SharePoint lists. (Microsoft)
2. Optimize backend queries. If using SQL or similar, ensure indexes are in place, avoid scans, design views or materialized views to simplify what the app needs to fetch. (Microsoft)
3. On-premises gateway location/performance. If your data source is on-prem, the gateway’s health, network latency, and resource allocation matter. Users far from the gateway or with network delays will experience slow performance. (Microsoft)

6. Monitoring, Testing & Iterative Improvement

1. Use Power Apps Monitor tool. Profile app startup, screen transitions, data calls; identify which calls or actions are longest. (Microsoft Learn)
2. Performance Checker / Solution Checker. Use built-in tools to detect issues (unused controls, non-delegable queries, etc.). (Microsoft Learn)
3. Test on target devices / networks. What’s fast in a dev environment with good WiFi may be slow on a mobile device or spotty connection. Test under realistic conditions.
4. Iterate. Performance tuning is rarely “once and done.” As you add features, screens, data sources, revisit load time and responsiveness.
5. Sample Optimization Strategy: Before & After

Best Practices Summary Checklist

Here’s a brief checklist you can use to audit or build an app with good performance from the start:

•  Does OnStart contain only essential logic/data for first screen?
•  Are other data loads deferred to when needed (OnVisible, etc.)?
•  Are data source queries delegable?
•  Are only needed fields (columns) being fetched?
•  Are connector / network calls minimized and combined (using Concurrent where feasible)?
•  Are galleries/free‐form controls free of LookUp/Filter calls inside them to external sources?
•  Is the number of controls per screen reasonable? Are there hidden or unused controls/screens?
•  Are images/media optimized in size, format, and usage?
•  Have we tested on target devices and network conditions?
•  Have we used performance tools (Monitor, Performance Checker, Solution Checker) to identify bottlenecks?

Challenges & Trade-Offs

It’s important to recognize that some optimizations come with trade-offs:

• Deferring data loading may create perceived latency when users navigate to later screens, so you may need loading indicators.
• Caching data may lead to stale data or complexity in refreshing.
• Over-optimization can make the app harder to maintain if you over-fragment logic or spread out initialization.
• Some UI richness or graphics may be sacrificed for performance. You’ll need to balance user experience vs speed.

Conclusion

Reducing load times in complex Power Apps is absolutely possible—and pays off in terms of improved user experience, lower abandonment, and more reliable behavior (especially for mobile or low connectivity). The keys are:

• Loading only what’s needed at each stage;
• Pushing work to the server via delegation;
• Streamlining UI and control count;
• Deferring or batching actions rather than doing everything at startup;
• Monitoring, measuring, and iterating based on real data.

If you build this mindset and these habits into your dev process, you’ll find that complexity stops being a performance liability and becomes a strength.

Need Help?

If you're working on a Power App that feels sluggish or has long load times, I can help with a performance review of your app: identify bottlenecks, suggest optimizations specific to your data sources and screens, and help you build a roadmap to improving responsiveness.

OWASP Top 10 Meets Power Apps: Practical Security Patterns

The OWASP Top 10 isn’t just for web developers — it’s directly relevant to low-code too. In this session, we’ll explore how common security risks show up in Power Apps and walk through real-world patterns you can apply to protect sensitive data, enforce least privilege, and stay compliant at enterprise scale.