Canvas Apps: Performance and Offline Mode

Introduction to Canvas Apps Performance

Canvas Apps are one of the most flexible low-code solutions within Power Platform. They are designed to offer customizable user experiences optimized for both desktop and mobile devices. However, achieving high performance and a reliable offline experience requires following specific technical and architectural best practices.

The performance of a Canvas App depends on factors such as the number of data connections, the complexity of Power Fx formulas, caching usage, delegation of queries, and local data management. Moreover, offline mode requires specific configurations to synchronize data with Dataverse or other sources once the connection is restored.

Data Caching and Reducing Calls

Caching in Canvas Apps helps reduce the number of requests made to external connectors and improves response times. Using functions like Collect() and ClearCollect() allows you to store data locally and reuse it across multiple screens.

It’s crucial to refresh data only when necessary, such as when the app starts or when explicitly requested by the user. This reduces load times and API impact. When working with Dataverse, using the client-side API and cache control reduces latency and enhances the offline experience.

• Store static datasets in temporary collections.
• Avoid repetitive calls to slow or non-delegable connectors.
• Implement conditional refresh logic to synchronize only changed data.

Delegation and Delegation Limits

Delegation allows Canvas Apps to execute operations like filtering and sorting directly on the server, preventing the transfer of entire datasets to the app. However, not all Power Fx functions are delegable. It’s essential to understand delegation limits and design formulas so they execute on the server.

For example, functions like Filter() and Sort() are delegable in Dataverse, while others like ForAll() or CountIf() are not. Applying non-delegable filters on large datasets may lead to incomplete results and poor performance.

Delegation Best Practices

• Always check formula delegability using the blue indicator in the designer.
• Use Dataverse or SQL data sources to support complex queries.
• Split datasets into logical pages to avoid record limits.

Optimizing Power Fx Formulas

Power Fx is the expression language of Canvas Apps, derived from Excel, allowing you to implement business logic and calculations. Optimizing formulas is critical for improving overall app performance.

• Avoid redundant or repeated formulas across multiple controls.
• Use context (UpdateContext()) or global (Set()) variables to store temporary results.
• Reduce nested LookUp() or Filter() calls.
• Avoid using Concurrent() for non-parallel operations.

Additionally, leveraging built-in monitoring features in Power Apps Studio (Monitor Tool) helps identify bottlenecks and optimize the performance of complex screens.

Offline Functionality and Synchronization

Offline mode in Canvas Apps is particularly valuable for field workers and scenarios where connectivity is intermittent. It enables users to work with local data and automatically synchronize it once the connection is restored.

To enable offline support, the app should use local collections to store data and implement synchronization logic using functions like SaveData() and LoadData(). These functions allow saving data to local cache and reloading it when the app starts, ensuring operational continuity.

• Use SaveData() to store critical datasets locally.
• Apply LoadData() at startup to retrieve saved data.
• Manage synchronization conflicts using conditional logic.

Microsoft recommends thoroughly testing offline mode in realistic data environments to ensure synchronization consistency and prevent data loss.

Performance on Mobile Devices

Canvas Apps are designed to run on mobile devices using the Power Apps app for iOS and Android. However, mobile devices have limited processing power and memory compared to desktops. Therefore, optimizing design and logic is essential.

• Reduce the number of visible controls at any given time.
• Load images and multimedia resources only when necessary.
• Avoid complex formulas on events like OnVisible or OnStart.
• Test the app on devices with different connectivity and performance levels.

Mobile performance improves significantly when using delegable connectors and local caching. For more details, see the Microsoft documentation on offline apps.