Reducing OnStart Load Time in Power Apps
Introduction
When a Power Apps application starts, it executes the OnStart property, which often includes tasks like loading data, initializing variables, and setting up collections. If not optimized, OnStart can significantly slow down app performance, causing delays before users can interact with the app.
In this guide, we will explore step-by-step techniques to reduce OnStart load time, improve app responsiveness, and enhance overall performance.
1. Understanding OnStart and Why It Can Be Slow
1.1 What Happens in OnStart?
The OnStart property is executed when the app launches, and it commonly includes:
✅ Loading data from SharePoint, Dataverse, SQL, or APIs.
✅ Initializing variables and global collections.
✅ Setting user permissions and roles.
✅ Preloading images or assets.
1.2 Common Causes of Slow OnStart Load Time
🚨 Fetching too much data at once from external sources.
🚨 Multiple API calls that slow down initialization.
🚨 Using Collect() instead of ClearCollect() (which keeps old data in memory).
🚨 Unnecessary calculations or queries that can be deferred.
2. Optimizing OnStart Load Time
2.1 Avoid Loading Large Data Sets on Start
Instead of loading all records at once, load only the necessary data when needed.
Before (Bad Practice: Loading Everything on Start)
ClearCollect(AllOrders, Orders)
🚨 Problem: Loads all orders into memory at launch, slowing down the app.
After (Optimized: Load Minimal Data First)
ClearCollect(RecentOrders, Filter(Orders, CreatedDate >= Today() - 30))
✅ Loads only the last 30 days’ orders instead of everything.
2.2 Use Concurrent() to Run Functions in Parallel
Instead of running API calls one after another, use Concurrent() to fetch multiple data sets at the same time.
Before (Sequential Calls, Slower)
ClearCollect(Users, UsersTable);
ClearCollect(Orders, OrdersTable);
ClearCollect(Products, ProductsTable)
🚨 Problem: Power Apps waits for each query to finish before starting the next.
After (Optimized: Use Concurrent for Faster Execution)
Concurrent(
ClearCollect(Users, UsersTable),
ClearCollect(Orders, OrdersTable),
ClearCollect(Products, ProductsTable)
)
✅ All three collections load simultaneously, cutting load time by up to 50%!
2.3 Cache Data to Reduce API Calls
If your app frequently retrieves static data, store it locally using SaveData() instead of reloading it every time.
Step 1: Save Data for Offline Use
If(IsEmpty(LocalUsers), SaveData(Users, "UsersCache"))
- Saves
Usersdata locally only if it hasn’t been saved before.
Step 2: Load Cached Data Instead of Calling API
LoadData(Users, "UsersCache", true)
✅ This reduces API calls and speeds up app startup.
2.4 Use Lazy Loading Instead of Loading Everything on Start
Instead of fetching all data at once, load it in small chunks as needed.
Before (Bad Practice: Fetching All Data in OnStart)
ClearCollect(AllCustomers, Customers)
🚨 Problem: Fetches thousands of records before the app loads.
After (Optimized: Load Data Only When Needed)
ClearCollect(InitialCustomers, FirstN(Customers, 100))
✅ Loads only the first 100 records on app start.
✅ Additional records can load dynamically as the user scrolls.
2.5 Remove Unnecessary Variables & Collections
Avoid storing unnecessary data in global variables and collections, which increase memory usage.
Check and Remove Unused Variables
1️⃣ Go to File → Variables in Power Apps.
2️⃣ Identify unused global variables.
3️⃣ Remove unnecessary Set() statements from OnStart.
Example: Before (Storing Unnecessary Data in a Variable)
Set(CurrentUserData, LookUp(Users, Email = User().Email))
🚨 Problem: Loads full user data into memory even if only the name is needed.
After (Optimized: Store Only What’s Needed)
Set(CurrentUserName, User().FullName)
✅ Reduces memory usage and speeds up app launch.
2.6 Use StartScreen Instead of OnStart
Instead of executing everything in OnStart, defer certain actions until the user reaches the relevant screen.
Step 1: Set a Default Start Screen
Go to App → StartScreen and specify which screen to load first.
Step 2: Move Non-Essential Calls to the Screen’s OnVisible Property
Screen.OnVisible = ClearCollect(RecentInvoices, Filter(Invoices, CreatedDate >= Today()-30))
✅ Loads data only when the user reaches that screen, instead of at startup.
2.7 Use Collections Instead of Multiple LookUps
Using LookUp() multiple times can slow down execution. Instead, store the data in a collection and reference it.
Before (Bad Practice: Multiple LookUps in OnStart)
Set(UserRole, LookUp(UserRoles, Email = User().Email).Role)
Set(UserDepartment, LookUp(Departments, ID = UserRole.DepartmentID).Name)
🚨 Problem: Each LookUp() query slows down execution.
After (Optimized: Store in Collection Once & Use It Later)
ClearCollect(UserData, Filter(UserRoles, Email = User().Email));
Set(UserRole, First(UserData).Role);
Set(UserDepartment, First(UserData).Department)
✅ Only one data call instead of multiple.
3. Best Practices for Reducing OnStart Load Time
✅ Load Only Essential Data on Start → Fetch additional data only when needed.
✅ Use Concurrent() for Parallel API Calls → Reduces total wait time.
✅ Cache Static Data Using SaveData() → Reduces API calls for frequently used data.
✅ Implement Lazy Loading → Load small data chunks dynamically instead of all at once.
✅ Remove Unused Variables & Collections → Free up memory and improve performance.
✅ Use StartScreen & OnVisible Instead of OnStart → Defer unnecessary data calls.
✅ Store LookUp Data in Collections → Avoid multiple database queries.
4. Conclusion
Reducing OnStart load time in Power Apps is essential for creating a fast, efficient, and responsive app. By optimizing API calls, using lazy loading, caching static data, and running queries in parallel, you can significantly reduce app launch time and enhance the user experience.
Would you like specific optimizations for SharePoint, Dataverse, or SQL Server?