Performance benefits of unified interface

Model driven Power Apps and Dynamics 365 apps are presented using the unified interface (sometimes referred to as unified client interface – UCI) which has replaced the previously used web client (web client deprecation was recently announced). The unified interface is a modern web app that dynamically generates UI on the client. This is different from the legacy web client, which was a collection of server-rendered web pages and client code meant for outdated browsers. The unified interface’s new architecture allowed us to implement several optimizations, targeting performance in high-latency networks by reducing the number of network roundtrips required to load pages. With these enhancements, our customer production telemetry shows us improvements in load times up to 63% for grid loads, 37% for form loads, and 27% for app launches. These results are a comparison of current production apps on WebClient and UCI – actual performance will vary depending on the customizations, client hardware, and network conditions.

Let’s go over the ways in which the unified interface was built to be fast, and what you can do to take full advantage of its new features.

Getting the most out of modern browsers

The unified interface takes full advantage of features present in modern browsers to improve performance. For example, we ship ES6 code and have improved caching by using a ServiceWorker. These are modern features that browsers are optimizing for, meaning that we will get faster as browsers are updated.

What you can do: Use the latest versions of Edge or Chrome, as they are becoming faster with each update. If possible, do not disable browser caches, or wipe caches and the end of the session, as this will make the application much slower.

Efficient custom UI

The PowerApps Component Framework has deep links with the Unified Interface. This allows us to efficiently update the UI, fetch data early, and cache dependencies for performance and offline support. One reason that we’re able to do this is because the controls built with this framework are limited to a set of Unified Interface APIs, as opposed to including an open set of web technologies. Additionally, controls can use explicit data binding which allows us to speed up your app by preparing the necessary data & metadata in advance. Finally, controls are only updated when application data or other dependencies change, reducing the strain on the processor.

What you can do: Avoid using web resources to add iframe content. If possible, build custom UI with the PowerApps Component Framework instead. You will automatically benefit from ongoing performance improvements, similar to those you get by keeping your browser up to date. Also, avoid opening new windows – using in-app pages and dialogs is much faster, since it doesn’t need to load up the app from scratch.

Optimizing for what the user sees

The unified interface creates interface elements on demand as the user navigates, switches tabs, or scrolls. This means we can load a very complex page with hundreds of controls almost as quickly as a very simple one. Even though controls are only created as the user is about to see them, there is no delay because we prefetch relevant data and metadata (as described in more detail below).

Loading elements on demand also allows us to keep performance relatively consistent across devices. For example, phones have slower processors, but their smaller screens mean we can save time by loading a smaller part of the page.

What you can do: When designing pages, put what is most important at the top to make it most easily accessible for your users. Move infrequently used components to other tabs on a form, use role-based forms instead of showing & hiding components, and make sure that different workflows have dedicated dashboards and views. Feel free to use sections to organize your controls – this won’t make your forms slower.

Flexible application metadata

Unified interface apps are described by application metadata – it contains information on what pages, views, and controls the app displays. In the past, this metadata wasn’t cached consistently, and we relied on downloading large chunks of it at a time, which could slow down apps significantly.

In the unified interface, metadata is split into small chunks so we can load up only what we need for the current page. It’s also cached across sessions and we download useful metadata in advance.

What you can do: Keep in mind that publishing application updates will invalidate all metadata your users have already downloaded, temporarily increasing load times. Don’t publish updates more often than you need to, and consider doing it at the end of workdays to minimize impact on your users.

Modularized code

In unified interface, the code for each page, including customizations, is only loaded once the user navigates to it. This also applies to various components prompted by the user, such as dialogs and opt-in features. This way, we avoid downloading, parsing and compiling unnecessary code, thereby reducing the initial cost of loading the app.

What you can do: Keep in mind that loading JavaScript code is slow, so customizations and PowerApps components should be kept as small as possible. If possible, consider writing your logic using Power Automate or Business Rules instead.

Solution Checker

Are customizations making your app slow? It’s possible that other makers have run into a similar issue. Solution Checker is a tool that detects issues in client-side JavaScript and server-side plugins, and it includes checks for common performance issues.

For example, it identifies synchronous network calls that can freeze the user’s browser. It also detects when you use outdated server endpoints, which don’t benefit from the latest server performance improvements.

What you can do: Run the Solution Checker regularly, as we are continuing to increase the variety of issues it can recognize.

Next steps

We want to ensure that all apps built on the Power Platform work well. We’re continuing to improve the unified interface, and we also hope this article gave you some ideas on steps you can take to improve your app’s performance.

-Joris