Power Apps Canvas Functions — Part 10: Master Index, Delegation Table & Performance Patterns

📌 This is Part 10 — the final post in the complete Power Apps Canvas Functions series. Use it as your day-to-day reference cheat sheet.

9 Parts. 200+ Functions. One Reference.

You made it to the end of the series. This final post is structured differently from the previous nine — it’s a reference document, not a tutorial. No narrative introduction. No worked example per function. Just the consolidated tables you’ll want open when you’re building.

Three things live here: a full index of what each part covers and which functions you’ll find there, the delegation quick-reference for Dataverse and SharePoint, and the performance patterns that separate apps that scale from apps that crawl at 500 records. Bookmark this page. It’s the one you’ll come back to.

Series Index — What’s in Each Part

Delegation Quick Reference

Delegation determines whether a formula operates on all rows in the data source (server-side execution, scales to millions) or only the first 500–2000 rows loaded into memory (client-side, silently incomplete on large tables). Check this before building any gallery, filter, or aggregate on a large Dataverse or SharePoint table.

💡 The delegation limit is configurable up to 2000 rows in File → Settings → Advanced → Data row limit for non-delegable queries. The default is 500. But 2000 is still a hard cap — it’s not a solution for genuinely large data sources.

// Pattern — delegable load, then non-delegable freely:
ClearCollect(
  colMyProjects,
  Filter(Projects, Owner = User().Email, Status <> "Archived")  // delegable
);
Set(varGrouped, GroupBy(colMyProjects, "Region", "RegionProjects"));  // non-delegable — fine on collection
Set(varDistinctStatuses, Distinct(colMyProjects, Status));            // non-delegable — fine on collection

Variable Scope Quick Reference

Performance Patterns Quick Reference

Six patterns that have the biggest impact on app load time, responsiveness, and scalability. Every Canvas App architect should be able to apply all six without looking them up.

1 — Parallel data load with Concurrent

The single highest-impact optimization in Canvas Apps. Five sequential ClearCollect calls take ~5 seconds. The same five inside Concurrent take ~1 second — the time of the slowest single call.

// Correct — independent loads in parallel:
Concurrent(
  ClearCollect(colProjects, Filter(Projects, Owner = User().Email)),
  ClearCollect(colTasks,    Filter(Tasks, AssignedTo = User().Email)),
  Set(varCurrentUser,       LookUp(Employees, Email = Lower(User().Email))),
  ClearCollect(colConfig,   AppSettings)
);
// After Concurrent — runs once all four complete:
Set(varUserRole, Coalesce(varCurrentUser.AppRole, "Viewer"));
Set(varAppReady, true)

2 — Cache and work locally

Load data from the server using only delegable operations. Store the result in a collection. Then apply all non-delegable operations on the collection — no limits, no warnings.

// Load with delegable Filter + SortByColumns:
ClearCollect(
  colRecentOrders,
  SortByColumns(
    Filter(Orders, OrderDate >= DateAdd(Today(), -90, TimeUnit.Days), AssignedTo = User().Email),
    "cr_orderdate", SortOrder.Descending
  )
);
// Now everything works freely on the collection:
Set(varGroupedByRegion, GroupBy(colRecentOrders, "Region", "Orders"));
Set(varTopProduct,      First(Sort(colRecentOrders, Revenue, SortOrder.Descending)).ProductName)

3 — Single LookUp with With

Every LookUp is a network round-trip. If you need three fields from the same record, call LookUp once with With and reference the result three times — not three separate LookUp calls.

// Without With: 3 network calls
// LookUp(Employees, ID = varID).FullName
// LookUp(Employees, ID = varID).Department
// LookUp(Employees, ID = varID).ManagerEmail

// With With: 1 network call
With(
  {emp: LookUp(Employees, ID = varID)},
  If(
    IsBlank(emp),
    "Employee not found",
    emp.FullName & " — " & emp.Department & " (reports to: " & emp.ManagerEmail & ")"
  )
)

4 — Parse JSON once

ParseJSON is expensive. If you need multiple fields from the same JSON response, parse it once in a With block — not once per field.

// Without With: ParseJSON runs 4 times
// Text(ParseJSON(body).token)
// Value(ParseJSON(body).expiresIn)
// Text(ParseJSON(body).userId)
// Boolean(Text(ParseJSON(body).isAdmin))

// With With: ParseJSON runs once
With(
  {api: ParseJSON(HTTPConnector.ResponseBody)},
  Set(varToken,   Text(api.token));
  Set(varExpiry,  DateAdd(Now(), Value(api.expiresIn), TimeUnit.Seconds));
  Set(varUserID,  Text(api.userId));
  Set(varIsAdmin, Boolean(Text(api.isAdmin)))
)

5 — Freeze a batch timestamp before ForAll

Now() and UTCNow() re-evaluate on every formula call. Inside a ForAll loop, each Patch call with UTCNow() may get a slightly different millisecond value. Capture it once in a variable before the loop — all records in the batch get exactly the same timestamp.

// Wrong — each row gets a different timestamp:
ForAll(colItems, Patch(Log, Defaults(Log), {TS: UTCNow(), ...}))

// Correct — one timestamp for all rows in the batch:
Set(varBatchTS, UTCNow());
ForAll(
  colItems,
  Patch(Log, Defaults(Log), {TS: varBatchTS, ItemID: ThisRecord.ID, Action: "Processed"})
)

6 — Control GPS lifecycle explicitly

Location starts GPS tracking as soon as it’s first accessed — which drains battery. In field apps that run all day, the difference is measurable. Enable GPS only while capturing a value, then disable immediately.

// "Record location" button OnSelect:
Enable(Location);
Patch(
  FieldVisits,
  Defaults(FieldVisits),
  {
    Latitude:        Location.Latitude,
    Longitude:       Location.Longitude,
    Accuracy:        Location.Accuracy,
    RecordedAt:      Now(),
    TechnicianEmail: User().Email
  }
);
Disable(Location)  // stop GPS immediately — do not leave it running

Common Anti-Patterns — What Not to Do

Naming Conventions — Enterprise Standard

Series Complete

That’s all 200+ Power Fx functions — documented with typed signatures, enterprise examples, Watch out blocks, and Works well with patterns. Nine parts of reference material, one index to find it all.

A few things worth saying at the end of a series like this. First: the functions are the easy part. Knowing that ClearCollect exists is one thing; knowing when to use it instead of Collect, and why that matters on a screen that loads six times a day in a warehouse, is another. That gap — between knowing a function and knowing when it’s the right tool — is what real-world projects teach you.

Second: Power Fx evolves. Microsoft adds functions, deprecates behaviors, and adjusts delegation rules across releases. The best practice today may not be the best practice in 12 months. Keep an eye on the Power Apps blog and the Power Fx GitHub repository. The documentation on Microsoft Learn is the authoritative source for anything in doubt.

Third: if you’ve worked through all ten parts and built something with these functions, leave a comment below. What were you building? What was harder than you expected? That kind of feedback shapes what comes next on this site.