The Concurrent() Function Nobody Uses

The Problem

Most Power Apps load data sequentially in App.OnStart. Each ClearCollect or Set call waits for the previous one to finish before starting. If you load data from three sources that each take 1 second, your app takes 3 seconds to start.

Bad Approach: Sequential Loading

// App.OnStart -- runs one after another
ClearCollect(colCustomers, Customers);         // 1.2s
ClearCollect(colProducts, Products);           // 0.8s
ClearCollect(colOrders, ActiveOrders);         // 1.5s
Set(varUserProfile, Office365Users.MyProfile()); // 0.5s
// Total: ~4.0s

Each line blocks until the data is returned. The user stares at a loading screen for 4 seconds.

Good Approach: Concurrent() Loading

// App.OnStart -- all four calls fire at once
Concurrent(
    ClearCollect(colCustomers, Customers),
    ClearCollect(colProducts, Products),
    ClearCollect(colOrders, ActiveOrders),
    Set(varUserProfile, Office365Users.MyProfile())
);
// Total: ~1.5s (limited by the slowest call)

All four data calls execute simultaneously. Total load time equals the duration of the slowest call, not the sum of all calls.

Rules

• No dependencies between calls. If colOrders needs a value from colCustomers, they cannot be in the same Concurrent() block.
• No guaranteed order. The calls may finish in any sequence.
• Errors are independent. If one call fails, the others still complete. Check results individually after the Concurrent() block.

Practical Pattern

Split your OnStart into independent and dependent groups:

// Step 1: Independent calls in parallel
Concurrent(
    ClearCollect(colConfig, ConfigTable),
    Set(varUser, Office365Users.MyProfile())
);

// Step 2: Dependent calls that need Step 1 results
ClearCollect(
    colMyTasks,
    Filter(Tasks, AssignedTo = varUser.Mail)
);

Key Takeaway

Audit your App.OnStart. Group independent data calls into Concurrent() blocks and keep dependent calls sequential. Most apps see a 2-3x improvement in startup time.