Dataverse ComboBox: Polymorphic Lookups

Key insights

• What it is: Bind a ComboBox in a canvas Custom Page to a polymorphic lookup in Dataverse so one control can select records from multiple tables.
  This embeds a canvas app inside a model-driven form and lets users pick items that may be Account, Contact, or other record types.
• Why use it: Provide a unified, flexible user experience where one control can show related records from different tables.
  It improves form usability and lets you build tailored interfaces and business logic while keeping data consistent in Dataverse.
• Key setup steps: Identify the polymorphic field and add each referenced table as a data source in the custom page.
  Combine those sources into the ComboBox Items (use a merged collection) and mark item type with @odata.type or an explicit flag for later logic.
• Selection and update logic: On ComboBox change, write Power Fx to Patch or call an API and include both the record ID and the entity logical name so Dataverse stores the correct polymorphic reference.
  Use ClearCollect/Collections for selection state and refresh relevant tables after updates.
• 2025 improvements: Microsoft added better patterns for Custom Pages and matured support for polymorphic fields.
  You can now call Custom APIs from Power Fx in many scenarios, simplifying complex updates and offering clearer migration guidance from standalone canvas apps.
• Best practices: Show visual differentiation (labels or icons) for each entity type, limit returned rows for performance, and implement retry/validation flows.
  Ensure proper security and permissions, test patch logic across referenced tables, and use Refresh only where needed to keep UI responsive.

Overview of the Video

Softchief Learn published a practical YouTube video that walks viewers through binding a ComboBox to a polymorphic lookup in Dataverse inside a Custom Page Canvas App embedded in a model-driven app. The presentation focuses on current patterns and provides step-by-step demonstrations to implement this integration. Moreover, the author highlights recent platform updates that make this pattern more feasible in 2025.

Overall, the video aims to bridge the gap between canvas flexibility and model-driven data contexts, showing how to let users select records from multiple tables in one control. In addition, the tutorial explains how to handle selection logic so the lookup stores both the record ID and the entity logical name correctly. As a result, teams can create more unified and user-friendly forms without sacrificing data integrity.

Why This Matters

This scenario matters because many solutions require a single lookup that can point to more than one table type, such as choosing either an account or a contact. Therefore, a working polymorphic lookup user interface removes friction for end users who otherwise must pick among different controls. Furthermore, embedding a canvas page inside a model-driven app gives app makers the freedom to design a richer experience while keeping the model-driven context.

Additionally, the video underscores that Custom Pages now better support advanced patterns like this compared with earlier releases. Consequently, organizations that need flexible forms can reduce the number of separate screens and duplicated logic. However, this new power also brings responsibilities for correct implementation and ongoing maintenance.

How the Binding Works

The author outlines a clear workflow for binding a ComboBox to multiple tables. First, you add each referenced table as a separate data source in the canvas page, then merge or present those records in a single collection. Next, you set the ComboBox Items property to that collection and use attributes such as @odata.type to tell which entity each item comes from.

• Identify the polymorphic lookup and its referenced tables.
• Add each table as a data source and combine records into one collection.
• Patch the lookup using both record ID and entity logical name on selection.

Finally, the video shows how to patch the record back to Dataverse so the field stores the correct ID and entity name. It also demonstrates navigation and refresh techniques with Power Fx formulas to keep the model-driven context synchronized. As a result, the binding behaves like a native lookup while offering canvas-level flexibility.

Tradeoffs and Performance Considerations

Implementing this pattern offers clear usability gains, but it also introduces tradeoffs that teams must weigh. For instance, combining multiple tables into one data source can affect performance when datasets grow large, so designers must plan filtering and delegation strategies. Moreover, relying on client-side merging can increase memory use and reduce responsiveness on low-end devices.

On the other hand, using server-side filters, indexed queries, or calling Dataverse Custom APIs from Power Fx can reduce client load but adds development complexity and potential security considerations. Therefore, you should balance immediate user experience improvements against longer-term maintainability and operational cost. In addition, updating patterns as the platform evolves requires governance to prevent fragmentation across apps.

Challenges and Recommended Practices

The video calls out several practical challenges and suggests mitigations that are useful for implementers. First, designers must present clear visual cues so users know the entity type for each option, for example by adding icons or explicit labels. Second, correctly patching polymorphic fields requires sending both the GUID and the entity logical name, which can be error-prone if not handled consistently.

Moreover, the author recommends testing with realistic data volumes and user scenarios, and using delegation-friendly functions to avoid client-side limits. He also suggests documenting the mapping logic and access patterns so future maintainers understand how records flow between the canvas page and Dataverse. Ultimately, solid testing and clear documentation reduce the risk of data mismatch and support smoother upgrades.

Conclusion and Next Steps

In summary, Softchief Learn’s video provides a timely and practical guide for binding a ComboBox to a polymorphic lookup in Dataverse using Custom Pages, and it highlights the improved capabilities available in 2025. The walkthrough balances hands-on steps with explanation of platform changes, making it useful for both app makers new to Custom Pages and those updating legacy canvas solutions. Consequently, teams will find the guidance valuable when designing unified forms for complex data models.

To move forward, organizations should pilot the pattern on low-risk forms, measure performance, and refine filtering strategies before wide rollout. Also, keep an eye on official product updates and community samples, because Microsoft continues to evolve the best practices around Custom Pages and polymorphic fields. Finally, careful design and governance will help you reap the user experience benefits while managing the technical tradeoffs effectively.

Related links

• Microsoft Dataverse
• Power Apps
• Model-Driven App
• Developer Tools

Keywords

Dataverse polymorphic lookup, Bind combobox to Dataverse, Power Apps Canvas app combobox binding, Polymorphic lookup combobox Power Apps, Bind combobox to form field Dataverse, Custom page Canvas app Dataverse lookup, Canvas app custom page combobox binding, Form field lookup Power Apps Dataverse