Form Designer Controls

This lesson is part of a module focused on building applications using Microsoft Power Apps, specifically delving into the creation of Model-Driven Apps. In this section, we're going to explore one of the most fundamental aspects of Model-Driven App development: Form Designer Controls. These controls are the building blocks of any form within your application, dictating how users interact with data, how information is displayed, and ultimately, how intuitive and efficient your app becomes.

Introduction: Shaping User Experience with Form Designer Controls

Imagine a spreadsheet with hundreds of columns and rows of data. While comprehensive, it's hardly user-friendly for daily tasks like updating a customer's contact information or logging a new sales opportunity. This is where forms in Model-Driven Apps come into play. Forms provide a structured, organized, and guided interface for users to view, create, and modify records in your Dataverse tables. They transform raw data into a digestible, actionable experience.

At the heart of every form are its controls. A control is essentially a visual element that either displays data or allows a user to input data. Think of text boxes, dropdown lists, checkboxes, date pickers, or even more complex elements like subgrids that show related records. The choice and configuration of these controls are paramount because they directly influence the user's experience, the accuracy of the data collected, and the overall efficiency of business processes. A well-designed form, utilizing the right controls, can significantly reduce errors, speed up data entry, and make your application a joy to use. Conversely, poorly chosen or configured controls can lead to frustration, data quality issues, and low user adoption.

In this comprehensive lesson, we'll dive deep into the world of Form Designer Controls. We'll start by understanding the basics of the Form Designer itself, then explore the array of standard and specialized controls available. We'll walk through practical examples of how to configure these controls, discuss best practices for form design, and highlight common pitfalls to avoid. By the end of this lesson, you'll have a solid understanding of how to leverage these powerful tools to create highly effective and user-friendly Model-Driven App forms.

Understanding the Form Designer Interface

Before we delve into specific controls, let's briefly orient ourselves within the Form Designer. This is the canvas where you'll assemble and configure all the elements of your forms. You typically access the Form Designer through the Power Apps maker portal (make.powerapps.com). From there, you navigate to a specific solution, then to a table (formerly known as an entity), and finally to the "Forms" section for that table.

When you open a form in the designer, you'll notice a few key areas:

Header: This section typically displays core information about the record that remains visible regardless of which tab the user is on. Common fields here include the record's primary name, status, or owner.
Body: This is the main content area of the form, organized into tabs and sections, which hold the majority of your fields and controls.
Footer: While less common for standard record forms, footers can sometimes be used for specific purposes, though they are often reserved for system-generated information or hidden entirely.
Left Pane (Components/Fields): This pane allows you to drag and drop fields from your Dataverse table onto the form or add various components like subgrids, quick view forms, or tabs.
Right Pane (Properties): When you select a form element (a tab, section, or control), this pane displays its configurable properties, allowing you to customize its appearance and behavior.

The Form Designer provides a What-You-See-Is-What-You-Get (WYSIWYG) experience, meaning you arrange elements visually, and the resulting form will largely reflect that layout in the running application. The controls we'll discuss are the individual pieces you place within the header and body sections to display or capture data.

Core Field Controls: The Building Blocks of Data Interaction

Most of the controls you'll use on a form are directly tied to a specific column (field) in your Dataverse table. Power Apps automatically suggests a default control type based on the column's data type (e.g., text for a text column, a date picker for a date column). However, you often have the flexibility to change this default to better suit your user experience needs.

Let's explore the most common core field controls:

1. Text Controls

These controls are used for columns that store textual information.

Single Line of Text: This is the most basic text input. It's suitable for short, concise text entries.
- Text: The default for simple strings (e.g., Name, Title).
- Text Area: Allows for slightly longer single-line input but still within a defined character limit.
- Email: Provides basic email address validation (e.g., checks for '@' and '.'). The system may also allow users to click to compose an email.
- Phone: Offers basic phone number formatting and allows users to click to initiate a call on supported devices.
- URL: Validates for a URL format (e.g., 'http://' or 'https://'). Users can click to open the URL in a browser.
- Ticker Symbol: Specific for financial data, though often handled as plain text unless custom logic is applied.
Multi Line of Text: Used for longer text entries that require multiple lines, such as descriptions, notes, or comments. You can configure the number of rows visible by default.

Tip: When designing forms, always consider the expected length of user input. A "Single Line of Text" control is fine for a person's first name, but a "Multi Line of Text" control is much more appropriate for a detailed product description. Choosing the right control from the start improves both usability and data capture quality.

2. Number Controls

These are used for columns that store numerical data. Power Apps provides different number types to ensure data integrity.

Whole Number: For integers without decimal places.
- Text: Allows users to type the number.
- Number: Provides a numeric input field, often with spin buttons to increment/decrement the value.
- Time Zone, Duration, Language Code: These are specialized whole number types often used internally by Dataverse or for specific system configurations. While they are whole numbers, their semantic meaning guides their use.
Floating Point Number: For numbers with decimal places, where precision isn't absolutely critical (e.g., temperatures, ratios).
- Text: Allows typing.
- Number: Numeric input field.
Decimal Number: For numbers with decimal places where high precision is required, often in financial calculations (e.g., prices, percentages).
- Text: Allows typing.
- Number: Numeric input field.
Note: Always align the control type with the column's data type. If you have a Decimal Number column in Dataverse, ensure your form uses a Decimal Number control to prevent data truncation or rounding issues.

3. Date and Time Controls

Essential for capturing temporal information.

Date Only: Displays a calendar picker, allowing users to select a specific date without a time component.
Date and Time: Displays a calendar picker and a time selector, allowing users to specify both date and time.

Callout: Date and Time Behavior

When configuring Date and Time columns in Dataverse, you can choose their "Behavior": User Local, Date Only, or Time-Zone Independent. This setting profoundly impacts how dates and times are stored and displayed across different users and regions. For instance, "User Local" converts the stored UTC time to the user's local time zone, which is generally preferred for user-facing dates. "Time-Zone Independent" stores the time exactly as entered without any conversion, useful for events like birthdays where the exact time isn't critical or needs to be consistent globally. The control on the form will respect this underlying column behavior.

4. Choice and Yes/No Controls

These controls are crucial for standardizing data input and ensuring data consistency.

Choice (Option Set): Provides a predefined list of options for the user to select from. This prevents free-text entry errors and simplifies reporting.
- Dropdown: The most common display, showing a single selected value and expanding to a list on click.
- Radio Buttons: Displays all options as clickable circles, allowing only one selection. Best for a small number of options (typically 2-5).
- List: Displays all options in a scrollable list, allowing single selection.
- Multi-Select Choice (Multi-Select Option Set): Allows users to select multiple options from a predefined list. This appears as a multi-select dropdown or a list of checkboxes.
Note: Choices can be either "Global" (reusable across multiple tables) or "Local" (specific to a single column on a single table). Global choices promote consistency and easier management across your application.
Yes/No (Boolean): For binary choices.
- Checkbox: A classic checkmark box.
- Radio Buttons: Two radio buttons labeled "Yes" and "No".
- Toggle: A modern switch-like control (On/Off).
Tip: For Yes/No fields, the Toggle control often provides a more modern and intuitive user experience compared to a traditional checkbox, especially in mobile interfaces.

5. Lookup Controls

These controls are fundamental for establishing relationships between records in different tables.

Lookup: Allows users to search for and select a record from a related table. For example, on a "Contact" form, a "Company" lookup field allows you to link the contact to an existing "Account" record.
- Standard Lookup: The default, providing a search box with results appearing as the user types.
- Reference Panel: While not a standalone lookup control, a lookup field can be configured to display a "Reference Panel" which shows related records in a separate panel on the form, providing more context.
Practical Example: On an "Opportunity" form, you'll likely have a "Customer" lookup field linked to the "Account" table. When a user selects an account, other fields on the Opportunity form (like the customer's primary contact or address) could be automatically populated using quick view forms or JavaScript, enhancing efficiency.

6. File and Image Controls

For managing binary data like pictures or documents.

Image: Used for columns of type "Image" in Dataverse. It displays the image directly on the form and allows users to upload a new one.
File: While Dataverse supports file columns, they are often managed through the "Attachments" or "Notes" section of a record, which itself is a specialized control (Timeline). However, custom file upload controls can be built using PCF.

7. Currency Control

Currency: For financial values. This control typically displays the currency symbol and handles formatting based on the user's locale and the base currency of the Dataverse environment.
- Text: Allows typing.
- Number: Numeric input field.
Note: Currency fields in Dataverse are actually composed of two parts: the numerical value and a lookup to the "Currency" table which holds the currency code (e.g., USD, EUR). The form control automatically manages this relationship.

Specialized Controls and Components

Beyond the basic field-level controls, Model-Driven Apps offer several powerful components that display related data or extend form functionality in sophisticated ways.

1. Subgrids

A subgrid is a mini-grid embedded within a form that displays a list of related records from another table. It's incredibly useful for showing "one-to-many" or "many-to-many" relationships directly on a parent record's form.

Purpose: To provide contextual information by listing associated records without requiring the user to navigate away. For example, on an "Account" form, you might have a subgrid showing all "Contacts" associated with that account, or all "Opportunities" for that account.
Configuration:
- Table: The related table whose records you want to display (e.g., Contacts, Activities).
- Default View: Which public view from the related table should be used to filter and display records in the subgrid.
- Add New Button: Allows users to create new related records directly from the subgrid.
- See All Records Button: Navigates the user to the full view of the related table.
- Related Records Filter: You can filter the records shown in the subgrid to only include those related to the current record.
Practical Example: Displaying Related Opportunities

Let's say you're on an "Account" form. You want to see all open opportunities associated with this account.
1. In the Form Designer, select a section in the form body.
2. In the left pane, click "Components" and drag "Subgrid" onto the section.
3. In the Properties pane, for "Table", choose "Opportunity".
4. For "Default View", select "Open Opportunities".
5. Ensure "Show related records" is checked.
6. You can also enable "Show 'Add New' button" and "Show 'See All Records' button" for user convenience.
7. Save and Publish the form. Now, when you open an Account record, you'll see a list of its open opportunities directly on the form.

2. Timeline

The Timeline control is a specialized component that provides a unified view of activities and notes related to a record. It consolidates interactions like emails, phone calls, appointments, tasks, and notes into a single, chronological feed.

Purpose: To give users a quick historical overview of all engagements and communications related to the current record. It's invaluable for understanding the context and progression of a customer relationship, a case, or a project.
Configuration:
- You can specify which activity types (Tasks, Appointments, Emails, Phone Calls, etc.) should be displayed.
- Configure default filters, sorting order, and the ability for users to add new activities or notes directly from the timeline.
- Enable or disable the rich text editor for notes.
Note: The Timeline control is automatically added to many out-of-the-box forms (like Account, Contact, Case). It's a highly recommended component for almost any record that involves ongoing interaction.

3. Quick View Forms

Quick View Forms allow you to display information from a related record without navigating away from the current form. They are particularly useful when you need to show details from a lookup record.

Purpose: To provide contextual information from a related entity, enhancing the user's understanding without cluttering the main form with redundant fields.
Configuration:
- You must first have a lookup field on your form that links to the related table.
- Select the lookup field in the Quick View Form properties.
- Specify the target table and the specific Quick View Form you want to display from that table.
Practical Example: Displaying Contact Details on an Opportunity

On an "Opportunity" form, you might have a "Primary Contact" lookup field pointing to the "Contact" table. Instead of adding individual fields like "Contact Phone" and "Contact Email" to the Opportunity form, you can create a Quick View Form on the "Contact" table that displays these fields. Then, on the Opportunity form, add a Quick View Form control, link it to the "Primary Contact" lookup, and select your "Contact Quick View Form". Now, when a user selects a primary contact for the opportunity, their phone and email will instantly appear in the Quick View Form, providing immediate context.

4. Reference Panels

A Reference Panel is a dedicated area on a form that can host multiple subgrids and quick view forms within a tabbed interface. It's essentially a container for related information.

Purpose: To organize and present various related lists and details in a compact, tabbed format, preventing forms from becoming excessively long or cluttered.
Configuration: You add a Reference Panel control to a section, then drag subgrids and quick view forms into the tabs within the panel.

5. Web Resources (HTML, JavaScript, Images)

Web resources allow developers to extend the functionality and appearance of Model-Driven Apps using standard web technologies.

Purpose:
- HTML Web Resources: Embed custom HTML pages directly onto a form to display complex layouts, custom charts, or interactive elements that aren't possible with standard controls.
- JavaScript Web Resources: Attach custom client-side scripts to form events (like OnLoad, OnSave, OnChange) to implement complex business logic, validations, or UI manipulations.
- Image Web Resources: Display custom images or icons on forms.
Warning: While powerful, Web Resources, especially custom JavaScript, require careful development and testing. Poorly written code can significantly impact form performance, introduce security vulnerabilities, or break after platform updates. Always follow best practices for client-side development and thoroughly test your solutions.

6. IFRAME

An IFRAME control allows you to embed content from another website or application directly within your Model-Driven App form.

Purpose: To display external web content (e.g., a map, a company's public website, a dashboard from another system) within the context of your record.
Configuration: You provide the URL of the content you want to embed.

Warning: Be extremely cautious when using IFRAMEs. They can pose security risks if the embedded content is not trusted. Always ensure the source is secure and consider the potential for "clickjacking" or other vulnerabilities. Performance can also be affected if the embedded site is slow to load.

7. Custom Controls (Power Apps Component Framework - PCF)

The Power Apps Component Framework (PCF) empowers developers to create custom code components that can be used in Model-Driven Apps (and Canvas Apps). These components can offer highly customized user experiences that go beyond the capabilities of the standard out-of-the-box controls.

Callout: The Power of PCF Controls

PCF controls represent a significant leap in customization for Power Apps. Unlike Web Resources, which are essentially embedding entire web pages, PCF controls are true components that integrate seamlessly with the Power Apps platform. They interact directly with Dataverse columns, respond to form events, and adhere to the platform's rendering engine. This allows for rich, interactive UI elements like signature pads, star ratings, advanced data visualizations, custom input masks, or even complex data entry grids. While creating PCF controls requires developer skills (TypeScript, React, etc.), once built and imported into your environment, they can be added to forms by app makers just like any other control, greatly extending the platform's capabilities.
How to Add Them:
1. A developer creates and packages a PCF control.
2. The control is imported into your Dataverse environment as part of a solution.
3. In the Form Designer, select a field.
4. In the Properties pane, navigate to the "Components" tab.
5. Click "Add Component" and select your custom PCF control from the list.
6. Configure any properties exposed by the PCF control.
Practical Example Idea: You might have a "Customer Satisfaction" field that's a whole number. Instead of a simple text box, a PCF control could display this as a 5-star rating selector, making it more visually appealing and easier for users to input.

Form Layout and Structure Controls

Beyond individual field controls, the Form Designer offers elements to organize and structure your form, making it navigable and user-friendly.

1. Tabs

Tabs are used to break down a long form into logical, manageable sections. This prevents information overload and allows users to focus on relevant data.

Standard Tabs: Each tab represents a distinct section of the form (e.g., "Summary," "Details," "Related," "Administration").
Tab Column Layouts: You can configure tabs to have one, two, or three columns for sections within them, influencing how fields are arranged horizontally.

2. Sections

Sections are containers within tabs that further organize fields into logical groupings. They often have a label that describes the group of fields within them.

Standard Sections: Can be configured to have one, two, three, or four columns.
Display Options: You can choose to show or hide the section label, or even lock the section to prevent users from accidentally moving fields.

3. Spacer

A simple control that adds empty space to a section, useful for visual alignment and breaking up dense areas of fields.

Configuring Control Properties: A Step-by-Step Guide

Every control on a form has a set of properties that you can configure to customize its appearance and behavior. Let's walk through common configuration steps.

Accessing Control Properties:

Open your Model-Driven App in the Power Apps maker portal (make.powerapps.com).
Navigate to "Solutions," open your desired solution, and find the table you want to modify.
Go to the "Forms" section for that table and open the relevant form (e.g., the Main form). This will launch the Form Designer.
On the form canvas, click on the field or control you wish to configure.
The "Properties" pane will appear on the right side of the screen, displaying all configurable options for the selected control.

Common Properties:

Display Options:
- Label: The text displayed next to the field on the form. This can be different from the column's display name.
- Hide label: Check this if you want the field value to appear without a label (e.g., for a large text area or a web resource).
- Visible by default: Determines if the control is shown when the form loads. You can use business rules or JavaScript to change visibility dynamically.
- Read-only: Makes the field non-editable. This can also be controlled by business rules or security roles.
Formatting:
- Number of columns: For sections, determines how many columns fields are arranged into.
- Field width: For some controls, allows you to specify a relative width.
Control Type (Components): This is where you can change the visual representation of a field.

Tip: Always use descriptive labels for fields. Avoid abbreviations or jargon that might not be clear to all users. Clarity is key to usability.

Step-by-Step Example 1: Changing a Text Field to a Multi-Line Text Area

Let's say you have a "Description" field on your form, which is currently a single-line text box, but users need more space for detailed input.

Open the Form Designer: Navigate to your table's main form in the Power Apps maker portal.
Select the Field: Click on the "Description" field on the form canvas.
Access Properties: In the right-hand "Properties" pane, ensure you are on the "Properties" tab.
Change Control Type: Scroll down to the "Components" section. You'll likely see "Text" listed as the current component.
Add Component: Click "Add Component."
Select New Control: In the "Add Component" dialog, select "Text Area."
Configure Properties: The "Text Area" component will have properties like "Number of rows." Set this to a higher value, for example, "5" or "10", to provide more vertical space.
Choose Default: After adding "Text Area," you'll see both "Text" and "Text Area" listed under "Components." Select "Text Area" and ensure the radio button next to it is chosen for "Web," "Phone," and "Tablet" to make it the default control for all form factors.
Save and Publish: Click "Save" in the top right corner of the designer, then "Publish."

Now, when users open a record with this form, the "Description" field will appear as a multi-line text area, providing ample space for their input.

Step-by-Step Example 2: Adding a Subgrid for Related Records

You want to display all "Task" activities related to a specific "Project" record directly on the Project form.

Open the Form Designer: Open the main form for your "Project" table.
Add a Section: If you don't have a suitable section, drag a "1-Column Section" from the left "Components" pane onto your form where you want the subgrid to appear (e.g., on a "Related" tab). Give the section a meaningful label like "Project Tasks."
Add Subgrid Component: Select the newly added section. In the left "Components" pane, drag the "Subgrid" component into this section.
Configure Subgrid Properties: In the right-hand "Properties" pane for the subgrid:
- Name: Give it a unique name (e.g., subgrid_ProjectTasks).
- Label: Enter a user-friendly label (e.g., "Project Tasks").
- Table: Select "Activity" (tasks are a type of activity).
- Default View: Choose a view that shows relevant tasks, such as "My Tasks" or "All Tasks." You might need to create a custom view if the existing ones don't fit.
- Related Records: Ensure this checkbox is selected. This tells the subgrid to only show activities related to the current Project record.
- Show 'Add New' button: Check this if you want users to create new tasks directly from this subgrid.
- Show 'See All Records' button: Check this if you want users to navigate to the full list of tasks.
- Show Search box: Check to allow searching within the subgrid.
Save and Publish: Click "Save" and then "Publish."

Now, when a user opens a "Project" record, they will see a subgrid displaying all associated tasks, providing a comprehensive view of the project's activities.

Best Practices for Form Design and Control Usage

Designing effective forms is an art as much as a science. Following these best practices will lead to more user-friendly, efficient, and maintainable Model-Driven Apps.

Simplicity and Clarity:
- Don't Overload Forms: Avoid putting too many fields on a single form or tab. Users get overwhelmed by dense forms. Use tabs, sections, and Quick View Forms to break down information logically.
- Minimize Scrolling: Try to fit essential information "above the fold" (visible without scrolling) or on the first tab.
- Clear Labels: Use plain language for field labels. Avoid technical jargon or abbreviations.
Logical Grouping and Flow:
- Group Related Fields: Place fields that belong together in the same section. For example, all address fields in an "Address Information" section.
- Follow a Natural Flow: Arrange fields in an order that makes sense to the user, typically from top to bottom, left to right, following the natural progression of data entry or a business process.
Consistency:
- Standardize Layouts: Maintain a consistent layout across different forms within your application. If one form uses a two-column section for contact details, try to use a similar layout on other forms.
- Consistent Control Usage: Use the same control type for similar data across forms (e.g., always use a Toggle for Yes/No fields).
Accessibility:
- Keyboard Navigation: Ensure all interactive elements can be accessed and operated using only a keyboard. Model-Driven Apps generally handle this well, but custom controls or complex HTML web resources need careful consideration.
- Screen Readers: Design with screen readers in mind. Use clear labels and avoid overly complex layouts.
Performance Optimization:
- Minimize Complex Controls: While powerful, custom PCF controls, complex Web Resources, and numerous subgrids can impact form load times. Use them judiciously and optimize their performance.
- Lazy Loading: Model-Driven Apps often lazy-load content on inactive tabs. Leverage this by placing less frequently accessed information on later tabs.
- Efficient Views for Subgrids: Ensure the default views selected for subgrids are optimized for performance and only retrieve necessary columns.
Data Integrity and Validation:
- Use Appropriate Control Types: Always select the control type that best matches the data type and expected user input (e.g., Email control for email addresses, Choice for predefined lists). This leverages built-in validation and improves data quality.
- Leverage Business Rules: Use Power Apps Business Rules to enforce conditional logic, make fields required, set visibility, or validate data without writing code.
Responsive Design Considerations:
- Model-Driven Apps are inherently responsive, adapting to different screen sizes (web, tablet, phone). However, your layout choices (e.g., number of columns in sections) still affect how content reflows. Test your forms on various devices.
Iterative Design and User Feedback:
- Prototype and Test: Build a prototype and gather feedback from actual users early and often. Their insights are invaluable for identifying usability issues and improving the design.
- Refine Continuously: Form design isn't a one-time task. As business needs evolve, so too should your forms.

Common Pitfalls and How to Avoid Them

Even experienced app makers can fall into common traps when designing forms. Being aware of these can save you a lot of headaches.

Overcrowded Forms:
- Pitfall: Stuffing too many fields onto a single form, leading to excessive scrolling and a daunting user experience.
- Avoidance: Utilize tabs to segment information. Use Quick View Forms to show related data concisely. Consider creating multiple forms for different user roles or stages of a business process (e.g., an "Information" form vs. a "Sales Process" form).
Inconsistent Naming and Labels:
- Pitfall: Using different labels for the same concept across various forms or within the same form (e.g., "Contact Person" on one form, "Primary Contact" on another).
- Avoidance: Establish clear naming conventions for fields, tabs, and sections. Review your forms for consistency in terminology.
Using Generic Text Fields for Specific Data Types:
- Pitfall: Using a plain "Single Line of Text" control for an email address, phone number, or URL. This bypasses built-in validation and can lead to dirty data.
- Avoidance: Always select the specialized text types (Email, Phone, URL) or number types (Whole Number, Decimal Number) when appropriate. This leverages Power Apps' native validation and user experience features.
Excessive Use of Custom Controls (PCF/Web Resources):
- Pitfall: Relying heavily on custom code components for functionality that could be achieved with out-of-the-box controls or simpler configurations. This increases development cost, maintenance overhead, and potential for performance issues.
- Avoidance: Prioritize built-in controls and declarative configurations (like Business Rules) first. Only resort to custom controls when there's a clear, unmet business need that cannot be solved otherwise. Document your custom controls thoroughly.
Not Testing Thoroughly:
- Pitfall: Designing a form and publishing it without testing how it behaves for different users, in various scenarios, or on different devices. This can lead to broken business rules, visibility issues, or layout problems.
- Avoidance: Always test your forms with diverse data, different user roles (security roles), and on various form factors (desktop, tablet, phone). Test all business rules and JavaScript events.
Ignoring Form Performance:
- Pitfall: Adding many complex subgrids, multiple Quick View Forms, or heavy Web Resources to a single form, resulting in slow load times and a frustrated user base.
- Avoidance: Monitor form load times. Optimize subgrid views to retrieve only necessary data. Place less critical components on later tabs that are loaded on demand. Consider whether a specific piece of information truly needs to be on the main form or if it could be accessed via navigation or a separate app.
Poor Tab and Section Organization:
- Pitfall: Arranging tabs and sections without a clear logical flow, making it hard for users to find information or understand the relationships between fields.
- Avoidance: Group related fields logically. Name tabs and sections clearly. Use the "Summary" tab for the most critical, frequently accessed information. Follow a consistent order (e.g., general info, details, related records, administrative).

Quick Reference: Control Types and Their Best Use Cases

Control Type	Common Use Case	Key Benefit
Single Line Text	Short names, codes, simple identifiers	Simple, direct text input
Multi Line Text	Descriptions, notes, comments, large text blocks	Ample space for longer textual input
Choice (Dropdown)	Selecting from predefined options (e.g., Status)	Data consistency, reduces input errors
Multi-Select Choice	Selecting multiple predefined options (e.g., Skills)	Captures multiple selections from a fixed list
Yes/No (Toggle)	Boolean values (e.g., Active, Preferred)	Clear binary choice, modern UI
Whole/Decimal Number	Quantities, scores, financial amounts	Ensures numerical data integrity, basic validation
Currency	Monetary values, prices	Handles currency formatting and precision
Date Only/Date & Time	Birthdays, event dates, timestamps	User-friendly calendar/time selection
Lookup	Linking to related records (e.g., Customer on Case)	Establishes relationships, data integrity
Image	Profile pictures, product images	Visual representation, direct image upload
Subgrid	Displaying lists of related records (e.g., Contacts on Account)	Provides contextual related data without navigation
Timeline	Consolidated view of activities (tasks, emails)	Holistic historical view of interactions
Quick View Form	Showing details from a lookup record (e.g., Contact details on Opportunity)	Information at a glance, reduces form clutter
Web Resource (HTML)	Custom UI, complex visualizations	Extends UI beyond standard controls
Custom Control (PCF)	Rich interactive UI, specialized input (e.g., Star Rating)	Highly customized user experience, deep integration

Key Takeaways

Forms are the User Interface: In Model-Driven Apps, forms are the primary way users interact with Dataverse records. Their design directly impacts user experience and data quality.
Controls are the Building Blocks: Form Designer Controls are the individual elements (text boxes, dropdowns, subgrids) that display data or capture user input.
Leverage Standard Controls First: Power Apps provides a rich set of out-of-the-box controls that cover most common scenarios. Utilize these for efficiency, consistency, and maintainability before resorting to custom solutions.
Specialized Controls Enhance Context: Components like Subgrids, Timeline, and Quick View Forms are crucial for providing users with comprehensive, contextual information about a record without requiring extensive navigation.
PCF Offers Advanced Customization: For unique UI/UX requirements, the Power Apps Component Framework (PCF) allows developers to create highly customized controls that integrate seamlessly with Model-Driven Apps, but this requires coding expertise.
Thoughtful Design is Paramount: Effective form design involves logical grouping (tabs, sections), clear labeling, consistent layouts, and a focus on user experience to prevent clutter and ensure intuitive data entry.
Prioritize Performance and Data Integrity: Always choose control types that match your data to leverage built-in validation. Be mindful of the performance impact of complex controls and always test your forms thoroughly across different devices and user roles.