Collab365

Power Apps People Picker Issue

Q: Is the V2 search function safe from delegation warnings?

Yes, it is entirely delegation-safe. Office365Users.SearchUserV2 delegates the search to Microsoft Graph servers, bypassing canvas app delegation limits.

Q: Why does the Combo Box sometimes display the claims prefix instead of the user's name?

This is a visual rendering issue. Set Combo Box DisplayFields to ["DisplayName","Mail"] instead of ["Claims"] to fix the display without affecting data payload.

C

Collab365AuthorPublished Apr 22, 2026

1

At a Glance

Target Audience: Power Apps Developers
Problem Solved: Custom Combo Box with Office365Users.SearchUserV2 returns Azure AD users that fail to patch to SharePoint Person or Group columns, causing blank fields or errors.
Use Case: Enterprise forms in Power Apps with searchable, delegable people pickers saving to SharePoint lists.

Your custom Combo Box Items formula breaks SharePoint patching because it returns Azure AD User objects, not the highly specific SharePoint Person format. Fix it instantly by pasting this JSON template directly into the Update property of your data card: {'@odata.type':"#Microsoft.Azure.Connectors.SharePoint.SPListExpandedUser", Claims:"i:0#.f|membership|" & Lower(cboPerson.Selected.Mail), Email: cboPerson.Selected.Mail}.

If you are reading this, you have likely built a beautiful, searchable people picker using a Power Apps Combo Box. You hooked it up using the Office365Users.SearchUserV2 function. It looks fantastic in the app preview, pulling in names, emails, and profile pictures perfectly. But the moment you hit the submit button to save that record to your SharePoint 'Person or Group' column, the field patches entirely blank, or the app throws a cryptic network error.

Key Takeaway: The Power Apps Patch function cannot automatically translate a custom Azure AD search result into a SharePoint Person column. You must manually construct the translation using the SPListExpandedUser JSON format.

This is the exact solution for Power Platform v2026, encompassing the latest modern control updates and Microsoft Graph People API integrations. We will explore exactly why this fails and how to permanently fix it.

TL;DR / Quick Fix Box

For developers actively debugging a broken production form, here is the immediate fix to get your app patching correctly:

(1) Keep your custom Items: Do not delete your Office365Users.SearchUserV2 formula from the Combo Box. The search logic is correct; the saving logic is the problem.
(2) Set Update to JSON with @odata.type: Select the parent Data Card (not the Combo Box). In the advanced properties, replace the Update property with a JSON object defining @odata.type as "#Microsoft.Azure.Connectors.SharePoint.SPListExpandedUser".
(3) Format Claims from Selected.Email: Inside that JSON, you must format the Claims property exactly as "i:0#.f|membership|" & Lower(cboPerson.Selected.Mail). SharePoint will reject the patch without this exact prefix.
(4) Handle multi-select if needed: If your SharePoint column allows multiple users, wrap your JSON object inside a ForAll loop that iterates over your Combo Box's SelectedItems.
(5) Validate with Microsoft Graph: For apps running on 2026 infrastructure, ensure you are testing against the new Graph API people domain semantic labels to future-proof your search queries.

Key Takeaway: Altering the Combo Box alone is never enough to fix a patching issue. The Data Card itself controls the data payload sent to the data source.

Who Is This Guide For and What You'll Get?

This guide is precision-engineered for the Power Apps developer with one to two years of experience. You have mastered the basics of generating forms, writing SubmitForm() actions, and executing basic Patch() functions. You know how to navigate the Power Apps Studio, and you have a destination SharePoint list configured with a standard Person column.

However, you are now hitting the limitations of the out-of-the-box controls. Building enterprise-grade apps requires replacing the rigid, standard SharePoint people picker with a modern, highly responsive custom Combo Box. The reader pain here is acute and universal: the custom picker works flawlessly in the app preview, but fails silently upon data submission.1

By following this technical breakdown, you will completely master the internal schema of the SharePoint Expanded User object. Furthermore, you will learn how to integrate the latest Microsoft Power Platform 2026 release wave features. This ensures your applications remain performant, safe from delegation warnings, and fully ready for AI-driven Copilot validation features.2

Key Takeaway: Transitioning from basic forms to enterprise applications requires manipulating the underlying data schemas. This guide bridges the gap between front-end UI design and back-end data architecture.

Why Does the Custom People Picker Fail to Save?

To understand the failure, we must look at a mini-story of how Power Apps development evolves. We used Choices() forever. When you generate a standard form from a SharePoint list, Power Apps automatically sets the Combo Box Items property to Choices(.YourPersonColumn). This native function is safe. It talks directly to SharePoint, and Power Apps handles all the background translation invisibly.

But then, user requirements grow. You need a people picker that searches 10,000 employees instantly, without delegation limits. So, you delete Choices() and write a custom search query using Office365Users.SearchUserV2(...). Custom search changed everything—it made the app incredibly fast. But it broke patching. Until you use the specific JSON fix, the app will remain broken.1

Why? Because of a fundamental data architecture mismatch.

When you query the Office 365 Users connector, you are communicating with Microsoft Entra ID (formerly Azure AD). This system returns a flat user profile containing basic attributes like DisplayName, Mail, and UserPrincipalName.

Conversely, SharePoint maintains its own legacy user information directory, governed by highly strict, claims-based authentication rules. SharePoint does not understand what a flat Azure AD user object is. It requires a fully expanded reference that explicitly maps the incoming user to its internal federated directory.5

Key Takeaway: Deleting the default Choices() formula breaks the native translation bridge. The app now speaks Azure AD, but the database only speaks SharePoint Claims.

If your Power App simply passes {Value: cboPerson.Selected.Mail} to the data card, SharePoint immediately rejects the payload. It lacks the strict OData typing and the federated claims prefix required to validate the user's identity.6

The Anatomy of the Claims Prefix

SharePoint is notoriously pedantic about how it receives identity data. The prefix "i:0#.f|membership|" is not just random formatting; it is a highly specific instruction set for the SharePoint authentication engine.8

Let us break down exactly what this string means according to SharePoint login formatting standards:

i: Indicates this is an identity claim.
0: Represents the Claim Value Type, signifying a string value format.
#: Indicates the exact formatting type.
.f: Signifies the Authentication Mode, specifically forms-based or federated authentication.8
|membership|: Defines the original issuer of the claim, instructing SharePoint to look at the federated membership provider (Azure AD).8

When you follow this prefix with the user's email address (e.g., i:0#.f|membership|jane.doe@company.com), you provide SharePoint with the exact cryptographically verifiable identity path it requires.9 Without this, the patch fails.

Key Takeaway: The claims string is a precise set of instructions for the SharePoint security token service. Missing even a single character will cause a silent submission failure.

Step-by-Step: Build a Searchable People Picker That Patches Perfectly

Constructing a highly functional, 2026-ready people picker requires precise configuration of both the Combo Box control and its parent Data Card. Follow these numbered steps to build the architecture correctly from the ground up.

Step 1: Connect the Data Sources

In Power Apps Studio, navigate to the Data pane on the left sidebar. Ensure your SharePoint list is connected. Next, search for and add the Office 365 Users connector.1 This connector is the engine that will drive your custom search functionality.

Step 2: Insert and Prep the Combo Box

Navigate to your edit form. Select the Data Card associated with your SharePoint Person column. You must unlock this card to make custom changes. Go to the properties pane on the right and click Unlock to change properties.

Delete the default dropdown control that Power Apps automatically generated. In its place, insert a modern Combo Box control from the top menu. Name this control cboPerson.

Step 3: Configure the Custom Search Formula

Select the cboPerson Combo Box. Navigate to the Advanced tab and locate the Items property. Paste the following formula:

Code snippet

Office365Users.SearchUserV2(
{
searchTerm: cboPerson.SearchText,
top: 20,
isSearchTermRequired: false
}
).value

Key Takeaway: Using the SearchUserV2 endpoint offloads the search query to the Microsoft servers, completely eliminating local delegation warnings and massive data downloads.1

This formula takes whatever the user types (cboPerson.SearchText) and passes it directly to the directory. The top: 20 parameter is crucial; it ensures the app only retrieves the first 20 matches, keeping performance lightning fast. The .value suffix extracts the resulting table of user records from the API response payload.7

Step 4: Configure Display and Search Fields

If you stop at Step 3, your Combo Box will likely display blank rows because it doesn't know which fields from the Azure AD object to render visually. While the Combo Box is selected, find the DisplayFields and SearchFields properties. Set them both to arrays containing the exact internal field names:

DisplayFields: ``
SearchFields: ``

This configuration ensures the user sees the person's full name, and allows them to search by typing either a name or an exact email address.1

Step 5: Configure the Parent Data Card Update Property

This is the critical step where 99% of developers fail. Select the parent Data Card—do not select the Combo Box. You must ensure the entire card boundary is highlighted. In the properties pane, locate the Update property. You will notice it currently holds an error or an old reference to the deleted dropdown.

Delete whatever is in the Update property. You are now going to paste in the magic JSON templates provided in the next section.

Key Takeaway: The Update property is the final gatekeeper. Whatever logic exists in this property is exactly what gets passed to the Patch or SubmitForm function.

The Magic Update Property JSON: Copy-Paste Templates

The exact syntax required for the Update property depends entirely on how your SharePoint list column was built. When you created the 'Person or Group' column in SharePoint, you either allowed a single selection or multiple selections.5

Scenario A: Single-Select Person Column

If your column permits only one user to be tagged, the Data Card must return a single JSON object.

Requirement	Configuration Details	Output Goal
OData Type	SPListExpandedUser	Declares the strict data schema to the SharePoint API.6
Claims String	Prefix + Email	Builds the `i:0#.f
Email Casing	Lower() function	Ensures case sensitivity does not trigger validation errors.

Copy and paste the following code block directly into the Update property of your data card (assuming your Combo Box is named cboPerson):

Code snippet

{
'@odata.type': "#Microsoft.Azure.Connectors.SharePoint.SPListExpandedUser",
Claims: "i:0#.f|membership|" & Lower(cboPerson.Selected.Mail),
Department: "",
DisplayName: cboPerson.Selected.DisplayName,
Email: cboPerson.Selected.Mail,
JobTitle: "",
Picture: ""
}

Every property here matters. The @odata.type must be wrapped in single quotes because of the @ symbol, which Power Apps would otherwise interpret as a functional operator.6 Notice how we use the Lower() function around the email address when constructing the Claims string. SharePoint claims resolution is highly sensitive; passing an email with capital letters can sometimes cause the internal federated lookup to fail.

Key Takeaway: Do not attempt to remove the blank fields like Department or JobTitle. Even if you are passing empty strings, providing the full schema ensures SharePoint accepts the object without schema validation warnings.

Scenario B: Multi-Select Person Column

When the SharePoint column is configured to accept multiple users, the underlying architecture changes radically. A single JSON object will immediately trigger an error. The Update property must now return a table (an array) of SPListExpandedUser records.4

To achieve this, we must use the ForAll function to iterate through the array of items the user has selected within the Combo Box, constructing a new JSON object for every single person.

Requirement	Configuration Details	Output Goal
Iteration Logic	ForAll loop	Loops through every selected item in the Combo Box.4
Data Scope	As _SelectedUser	Creates a safe local variable for the loop.
Array Output	Table of Objects	Returns the array structure SharePoint expects for multi-select fields.

Paste the following code into the Update property for a multi-select setup:

Code snippet

ForAll(
cboPerson.SelectedItems As _SelectedUser,
{
'@odata.type': "#Microsoft.Azure.Connectors.SharePoint.SPListExpandedUser",
Claims: "i:0#.f|membership|" & Lower(_SelectedUser.Mail),
Department: "",
DisplayName: _SelectedUser.DisplayName,
Email: _SelectedUser.Mail,
JobTitle: "",
Picture: ""
}
)

In this construct, the As _SelectedUser alias is absolutely vital. When running a ForAll loop inside a complex form, Power Apps can easily become confused between the fields of the current loop record and the fields of the broader form context. By assigning a distinct alias (_SelectedUser), you force the formula to reference only the specific properties of the user currently being processed in the loop.4

Key Takeaway: Multi-select columns strictly require a table of records. Using the ForAll loop translates an array of flat Azure AD users into a complex array of SharePoint Expanded Users.

Common Pitfalls and Troubleshooting Table

Even when armed with the correct JSON templates, subtle misconfigurations within the Power Apps Studio can derail the patching process. Analysing the most frequent errors encountered in production environments reveals a clear pattern. Use this troubleshooting table to diagnose and resolve immediate issues.7

Observed Error in App	Root Cause Analysis	Corrective Action to Apply
Field Patches Blank	The Claims prefix is either missing, contains a typo, or uses incorrect casing.	Ensure the string strictly begins with `"i:0#.f
"Network Error" on Submit	The @odata.type declaration is missing, misspelled, or lacks single quotes.	Verify the string is precisely "#Microsoft.Azure.Connectors.SharePoint.SPListExpandedUser". Ensure the single quotes surround @odata.type.6
Prefix Visible in App UI	The Combo Box is displaying the Claims property string instead of the actual name.	Change the Combo Box DisplayFields array in the properties pane to `` instead of ["Claims"].12
Yellow Delegation Warning	Attempting to use a local Filter() against a massive corporate directory.	Switch immediately to the Office365Users.SearchUserV2() endpoint, which offloads the query logic to the server side.1
Incorrect User Saved	The JSON formula erroneously uses the User().Email global function.	Ensure the JSON references cboPerson.Selected.Mail. Using User() will constantly overwrite the selection with the app creator's identity.

The visibility of the claims prefix in the user interface is a particularly notorious issue that causes panic among developers and end-users alike.12 Occasionally, after modifying a default form, the Power Apps Studio will automatically attempt to "help" by swapping the PrimaryText of the Combo Box to display the Claims property.

Users will suddenly see i:0#.f|membership|jane.doe@company.com instead of "Jane Doe" rendered on the screen.13 This is purely a visual rendering anomaly within the control, not a data corruption issue. Correcting the DisplayFields array via the control properties pane immediately resolves this visual glitch without impacting the underlying data payload.13

Key Takeaway: If you see the raw claims string in your app's text boxes, your patching logic is likely correct, but your control's display settings have been corrupted by the Studio's auto-formatting.

2026 Updates: Graph People API and Copilot Validation

The Microsoft Power Platform has undergone radical architectural shifts throughout the 2025 and 2026 release waves.2 While the core JSON fixing methodology remains relevant for SharePoint integration, how data is queried, validated, and designed is changing fundamentally. Relying solely on older connector methods without understanding the new Graph capabilities severely limits application scalability.

The Shift Toward Microsoft Graph People API

Historically, the Office365Users connector was the sole mechanism for executing custom directory searches within a canvas app. However, the 2026 rollouts heavily emphasise direct Microsoft Graph API integration.14 Microsoft has explicitly added 19 distinct "people domain semantic labels" to the Microsoft 365 Copilot connectors.16

These new semantic labels include highly specific organizational data points such as personEmails, personCurrentPosition, personSkills, personProjects, personManager, and personCertifications.16 These labels enable developers to map highly granular profile data directly from external systems into standardized properties.16

For a custom people picker, this means search queries can now transcend simple name matches. A developer can build a custom Combo Box that queries the Microsoft Graph for a specific corporate skill set. For example, a user could type "React Developer" into the Combo Box. The app uses the Graph API to return all users matching that personSkills label, populates the dropdown with those individuals, and then still patches the selected user back to the legacy SharePoint list using the identical SPListExpandedUser JSON logic detailed above.

Key Takeaway: The Microsoft Graph integration means your people picker can now act as an intelligent organizational search engine, rather than just a simple name directory, without breaking your database schema.

Copilot Form Validation and Modern Controls

The February 2026 update to modern controls in Power Apps fundamentally alters standard form behaviour.17 The legacy form controls you may be used to are being aggressively phased out in favour of modern UI elements that handle internal validation, layout spacing, and device responsiveness automatically.18

Furthermore, Copilot-driven form fill assistance introduces "smart data validation" directly into model-driven and canvas apps.19 When configuring a custom people picker today, developers must ensure their validation logic aligns with these modern AI parameters. While Copilot can intelligently validate standard email formats in text columns 19, the complex JSON payload required for SharePoint Person columns still demands explicit developer oversight.

You cannot rely on an AI agent to perfectly validate a complex SPListExpandedUser payload. The Form.Valid property remains the absolute source of truth for pre-submission checks, providing a definitive boolean output regarding whether the entire data structure is safe to send to the server.20

The "Vibe-Code" Reality Check

The 2026 release of the "App Agent" introduces the highly publicized concept of "vibe-coding".2 Vibe-coding allows developers to use natural language to generate robust React code and UI elements natively inside applications without manual programming.23 You simply describe the interface you want, and the App Agent builds it.

While this dramatically accelerates building consumer-grade user interfaces, Collab365 research indicates that relying on vibe-coding for legacy SharePoint integrations is hazardous.22 App Agents are fundamentally trained to prioritize the Dataverse Web API pathways. When an App Agent is asked via chat prompt to "create a people picker for my form," it frequently generates standard text inputs or basic dropdowns, rather than autonomously constructing the necessary SPListExpandedUser JSON logic.24

If you use the new Plan Designer to generate an app architecture 25, you must manually intervene post-generation. You must physically inspect the Data Cards and apply the magic JSON templates to ensure data integrity when bridging modern AI-generated interfaces with legacy SharePoint columns. The App Agent will design a beautiful Combo Box, but it will not write the claims string for you.

Key Takeaway: The 2026 App Agent will accelerate your UI design phase, but foundational knowledge of complex data types like SPListExpandedUser remains absolutely non-negotiable for SharePoint integration.

Best Practices for Production Apps

Deploying a custom people picker to a production environment demands strict adherence to architectural best practices. An application that functions smoothly for ten users will often buckle under the weight of ten thousand if the underlying queries are poorly configured.

Optimising Search Performance

According to Collab365 analysis, optimizing the search parameters yields significantly faster load times—up to 30% faster loads when utilizing the top 5 query filters effectively.

The Office365Users.SearchUserV2 function accepts a top parameter.1 Never leave this blank, and never request the maximum limit of 999 users. Setting the top parameter to top: 15 or top: 20 guarantees almost instantaneous directory returns.1 It completely avoids delegation warnings while returning more than enough relevant results for any human user to parse effectively on a standard screen.

Implementing Strict Validation Rules

Never allow a form to submit a partial or malformed identity payload. Utilize the Form.Valid property to disable the submit button dynamically.20 Furthermore, implement an explicit validation check on the Combo Box itself prior to executing the patch:

Code snippet

If(
IsBlank(cboPerson.Selected.Mail),
Notify("Please select a valid user from the organizational directory.", NotificationType.Error),
SubmitForm(frmMain)
)

This preemptive strike prevents the application from attempting to construct the i:0#.f|membership| string with a blank email variable, which would immediately trigger a harsh SharePoint rejection and confuse the end-user.

Caching for Repeat Operations

If an application requires users to select individuals from a specific department repeatedly throughout a workflow, querying Azure AD constantly via the V2 endpoint creates unnecessary network overhead. Instead, cache a pre-filtered collection upon application start using the OnStart property:

Code snippet

ClearCollect(
colITDepartment,
Office365Users.SearchUserV2({searchTerm: "IT", top: 50}).value
)

Your custom Combo Box can then use the local colITDepartment variable as its Items source. This provides instantaneous dropdown results without continuous external API calls, while still utilizing the exact same Update JSON property on the data card to ensure formatting compliance.28

Key Takeaway: Protect your application's performance by minimizing server calls. Use the top parameter aggressively and cache department-level queries locally during app initialization.

Testing Your Fix: Preview vs Published

Testing a people picker fix is notoriously deceptive within the Power Platform. A configuration might appear perfectly functional within the Power Apps Studio preview environment, yet fail spectacularly once published to the actual end-users. This discrepancy occurs because the Studio preview operates under the maker's elevated connection context and cached directory access.

To verify your JSON formatting is truly resolving the issue at the database level, follow a strict testing protocol:

Publish the Application: Do not rely on the Studio play button. Publish a distinct version and open the live URL in a fresh browser session.
Impersonate a Standard User: Test the application using a test account that possesses standard 'Contribute' access to the SharePoint list, but possesses zero maker privileges in the Power Platform environment.
Monitor the Network Trace: Press F12 to open the browser developer tools. Navigate to the Network tab and monitor the Patch or SubmitForm payload when you hit save. The outgoing request must clearly display the fully constructed SPListExpandedUser JSON object. If the payload contains only the raw email string, your Update property has been misconfigured and ignored.
Verify Claims Syntax: Open the destination SharePoint list directly. If the user's name appears correctly linked to their profile, the patch was successful. If the column displays the raw i:0#.f|membership| string, the SharePoint column settings are corrupted or the data was forced via an alternate text override method.13

Frequently Asked Questions

Can these JSON templates be used for a multi-person column? Yes. However, a multi-person column strictly requires a table of JSON records. The single-select JSON object will fail completely. Developers must use the ForAll template provided in Scenario B to iterate through the SelectedItems property and construct an array of expanded user objects.4

What happens if the User().Email function fails or returns an alias?

Relying on the global User().Email function to patch a current user into a Person column is highly dangerous. Some Azure AD configurations return a UPN (User Principal Name) that differs from the primary SMTP address recognized by SharePoint. Always route the selection through the Office365Users connector to obtain the definitive .Mail or .UserPrincipalName mapped to the active directory.

Is the V2 search function safe from delegation warnings? Yes, it is entirely delegation-safe. The Office365Users.SearchUserV2 function delegates the search query directly to the Microsoft Graph server side.1 Unlike attempting to use a local Filter() formula on a massive collection, the V2 endpoint processes the search externally and returns only the matched top results, bypassing the standard 500/2000 row canvas app delegation limits entirely.

Why does the Combo Box sometimes display the claims prefix instead of the user's name? This is a visual rendering issue within the control, not a data corruption issue. When configuring custom form controls, Power Apps occasionally alters the DisplayFields array automatically. Select the Combo Box and manually change the PrimaryText or DisplayFields array from ["Claims"] back to ``.12

Will the 2026 App Agent rewrite my custom JSON? If a developer uses natural language to request the App Agent to "rebuild the form" or "optimise the layout," the generative engine may overwrite custom Data Card Update properties.23 It is highly recommended to physically lock the specific Data Card containing the SPListExpandedUser logic via the properties pane before running broad AI-driven redesign commands across your screen.

Concluding Steps for Enterprise Implementation

Mastering the data architecture between Power Apps and SharePoint transforms a fragile, buggy application into a highly resilient enterprise tool. The discrepancy between a flat Azure AD user profile and a complex SharePoint SPListExpandedUser format is the root cause of nearly all custom people picker failures.

By meticulously applying the provided JSON templates to the Data Card's Update property, ensuring the strict i:0#.f|membership| claims format is maintained, and embracing the new 2026 Graph API semantic structures, developers can guarantee data integrity on every single submission.

The era of relying entirely on implicit Choices() formulas is over. As applications scale to handle thousands of users and modern controls become the definitive standard, granular control over your data payloads is essential. For further details of the 2026 Graph integration features, we highly recommend checking the advanced resources housed within the Power Apps Space on Collab365 Spaces. Implementing these exact practices today ensures that your applications will remain stable, performant, and fully compatible with the AI-driven future of the Microsoft Power Platform.