Microsoft PL-400 Power Platform Developer Exam Dumps and Practice Test Questions Set 1 Q1-15
Visit here for our full Microsoft PL-400 exam dumps and practice test questions.
Question 1.
You are developing a model-driven app in Power Apps. You need to ensure that when a user creates a new account record, the credit limit field is automatically set based on the account’s industry type. Which approach should you use to implement this requirement?
A) Create a business rule on the Account form
B) Create a JavaScript web resource and register it on the OnLoad event
C) Create a synchronous plugin registered on the PreCreate message
D) Create a Power Automate cloud flow triggered on record creation
Answer: C
Explanation:
This scenario requires setting a field value during the creation of a record before it is saved to the database. The most appropriate solution is to use a synchronous plugin registered on the PreCreate message of the Account entity.
A plugin is server-side code that executes in response to specific events in the Dataverse platform. When registered on the PreCreate message, the plugin runs before the record is written to the database, allowing you to modify field values based on business logic. This ensures data integrity and consistency regardless of how the record is created, whether through the UI, API, or integrations.
The PreCreate stage is specifically designed for scenarios where you need to set or modify field values before the record is committed to the database. Since the requirement involves setting the credit limit based on the industry type during creation, a synchronous plugin ensures this logic executes immediately and the record is saved with the correct values.
A) Business rules have limitations and cannot handle complex conditional logic based on option set values to set numeric fields. They are best suited for simple show/hide, required/not required, and basic field value operations.
B) JavaScript web resources execute on the client side and only work when users interact with forms in the UI. They would not trigger if records are created through other channels like APIs, integrations, or bulk imports, making this solution incomplete.
D) Power Automate cloud flows are asynchronous by default and trigger after the record is created. This means the record would be saved first without the credit limit, and then the flow would update it later, which doesn’t meet the requirement of setting the value during creation.
Question 2.
You are developing a canvas app that needs to display data from a custom API that is not available as a standard connector. The API requires OAuth 2.0 authentication and returns data in JSON format. What should you create to enable the canvas app to consume this API?
A) Custom connector
B) Dataverse custom API
C) Power Automate HTTP action
D) JavaScript web resource
Answer: A
Explanation:
When you need to connect a canvas app to an external API that doesn’t have a prebuilt connector, creating a custom connector is the recommended approach. Custom connectors allow you to define the API’s endpoints, authentication methods, and data structures so that Power Apps can communicate with external services seamlessly.
A custom connector acts as a wrapper around your REST API and provides a way to describe the API’s operations, parameters, and responses. It supports various authentication methods including OAuth 2.0, API key, basic authentication, and anonymous access. Once created, the custom connector appears alongside standard connectors in Power Apps and can be easily added to your canvas app just like any other data source.
The process of creating a custom connector involves either importing an OpenAPI definition or manually defining the API operations. For OAuth 2.0 authentication, you configure the identity provider settings including client ID, client secret, authorization URLs, and token URLs. After the connector is created and tested, it can be shared with other users in your organization and reused across multiple apps and flows.
B) Dataverse custom APIs are used to create custom business logic that runs on the Dataverse platform itself, not for connecting to external APIs. They are designed for creating reusable server-side operations within Dataverse.
C) Power Automate HTTP action could technically call the API, but this approach would require creating a flow for every API call, making it inefficient and difficult to maintain in a canvas app context. Custom connectors provide a more integrated experience.
D) JavaScript web resources are used in model-driven apps for client-side customization and cannot be directly used in canvas apps. They also don’t provide a structured way to handle OAuth 2.0 authentication for external APIs.
Question 3.
You need to create a plugin that updates related contact records when an account record is updated. The plugin should execute after the account record is saved to the database. Which stage and message should you register the plugin on?
A) PreOperation stage on the Update message
B) PostOperation stage on the Update message
C) PreValidation stage on the Update message
D) PreOperation stage on the Create message
Answer: B
Explanation:
When you need to perform operations on related records after the primary record has been successfully saved to the database, you should register your plugin on the PostOperation stage. The PostOperation stage executes after the database transaction is committed, ensuring that the account record has been successfully updated before attempting to update the related contact records.
The plugin pipeline in Dataverse consists of several stages that execute in a specific order. The PreValidation stage runs before any security checks, the PreOperation stage runs after security checks but before the database operation, and the PostOperation stage runs after the database operation is complete. For scenarios involving updates to related records, the PostOperation stage is ideal because it guarantees that the primary operation succeeded.
Using the PostOperation stage also provides access to the complete post-image of the record, which contains all the field values as they exist in the database after the update. This is particularly useful when you need to compare the updated values with the original values to determine which related records need to be updated.
A) PreOperation stage executes before the record is saved to the database. If you update related records at this stage and the primary operation fails, you would have inconsistent data with updated contacts but a failed account update.
C) PreValidation stage is the earliest stage in the pipeline and executes before security checks. It’s typically used for validating data or setting default values, not for updating related records, as the main operation might still fail later in the pipeline.
D) This option registers on the Create message instead of Update. Since the requirement specifically states updating an account record, the Create message would not trigger when existing account records are modified, making this incorrect.
Question 4.
You are building a Power Apps portal and need to display Dataverse data on a web page. The data should be filtered based on the currently logged-in portal user. Which feature should you use?
A) Entity permissions
B) Web page access control rules
C) Table permissions
D) Column permissions
Answer: C
Explanation:
Table permissions are the correct mechanism for controlling access to Dataverse data in Power Apps portals. They allow you to define which records portal users can create, read, update, or delete based on various criteria including the relationship to the logged-in user. Table permissions provide granular control over data access and can filter records based on the portal user’s contact record or account relationship.
When you configure table permissions, you specify the table you want to secure, the access type (Global, Contact, Account, Parent, or Self), and the privileges (Create, Read, Write, Delete, Append, and Append To). For the scenario described, you would typically use Contact scope to filter records related to the current user’s contact record, ensuring that each user only sees their own data.
Table permissions work in conjunction with web roles to determine what data a user can access. A portal user must be assigned to a web role, and that web role must be associated with the appropriate table permissions. This multi-layered security model ensures that data access is properly controlled and auditable.
A) Entity permissions is the old terminology used before the Dataverse naming changes. While functionally similar to table permissions, the current and correct term in Power Apps portals is table permissions, making this answer technically outdated.
B) Web page access control rules control access to specific web pages in the portal, determining who can view or access particular pages. They do not filter or control access to Dataverse data records, making them inappropriate for this data security requirement.
D) Column permissions are used to control access to specific fields within a table but do not provide record-level filtering based on the logged-in user. They work in conjunction with table permissions but cannot be used alone to filter data.
Question 5.
You are developing a solution that requires calling an external REST API from a Dataverse plugin. The API call may take several seconds to complete. How should you implement this to avoid blocking the user interface?
A) Register the plugin synchronously on the PostOperation stage
B) Register the plugin asynchronously on the PostOperation stage
C) Use a Power Automate flow with an HTTP action
D) Register the plugin synchronously on the PreOperation stage
Answer: B
Explanation:
When making external API calls from a plugin that may take several seconds to complete, you should register the plugin asynchronously. Asynchronous plugins execute outside the main database transaction and run in the background, preventing long-running operations from blocking the user interface or causing timeout errors.
Asynchronous plugins are queued and executed by the asynchronous service in Dataverse. This approach provides several benefits including improved user experience, as users are not forced to wait for external API calls to complete, better system performance, as synchronous operations have strict timeout limits, and automatic retry capability if the operation fails.
The PostOperation stage is the appropriate stage for asynchronous plugins because the primary database operation has already completed successfully. This ensures that the record exists in the database before the external API call is made. Asynchronous plugins also have access to the execution context and can retrieve the full record data needed for the API call.
A) Registering the plugin synchronously would block the user interface while waiting for the external API call to complete. Synchronous plugins have a two-minute timeout limit, and slow external APIs could cause the plugin to fail with timeout errors, resulting in a poor user experience.
C) While Power Automate flows can call HTTP actions and run asynchronously, using a plugin provides better integration with Dataverse, better error handling, and more control over the execution context. However, this could be an alternative solution in some scenarios but plugins offer more flexibility.
D) PreOperation stage executes before the database transaction commits. If the external API call fails or times out, the entire transaction would be rolled back. Additionally, synchronous execution would still block the user interface, making this approach inappropriate for long-running operations.
Question 6.
You need to create a PCF (PowerApps Component Framework) control that displays a custom chart visualization. Which method in the control lifecycle must you implement to render the control’s visual elements?
A) init()
B) updateView()
C) getOutputs()
D) destroy()
Answer: B
Explanation:
The updateView method is the core rendering method in the PCF control lifecycle and is responsible for displaying the control’s visual elements. This method is called whenever the control needs to be rendered or re-rendered, such as when the control first loads, when bound data changes, or when the container size changes. Inside this method, you manipulate the DOM to create or update your custom chart visualization.
The updateView method receives a context parameter that provides access to all the information the control needs including input properties, bound data, utility methods, and container dimensions. When developing a custom chart control, you would use this method to read the data from the context, process it as needed, and then render the chart using your chosen visualization library like Chart.js or D3.js.
This method is called frequently throughout the control’s lifecycle, so it’s important to implement it efficiently. You should check what has changed in the context before performing expensive rendering operations. The method should be idempotent, meaning it should produce the same result regardless of how many times it’s called with the same context.
A) The init method is called only once when the control is first loaded. It’s used for initialization tasks like setting up event handlers, initializing member variables, and storing references to DOM elements. While important, it’s not where the actual rendering of visual elements occurs.
C) The getOutputs method is used to return data from the control back to the host application, such as when a user interacts with the control and you need to update bound properties. It doesn’t handle rendering or visual display of the control.
D) The destroy method is called when the control is removed from the DOM. It’s used for cleanup tasks like removing event handlers, canceling network requests, and releasing resources. It’s the opposite of rendering and doesn’t display any visual elements.
Question 7.
You are implementing field-level security in Dataverse. A field contains sensitive salary information that should only be visible to HR managers. What must you do to enable field-level security on this field?
A) Create a security role with read privileges on the field
B) Enable security for the field in the field properties and create field security profiles
C) Set the field requirement level to Business Required
D) Create a business rule to hide the field from unauthorized users
Answer: B
Explanation:
Field-level security in Dataverse requires a two-step process. First, you must enable security on the specific field by modifying its properties in the table definition. This is done by setting the «Enable security» option to Yes in the field properties. Second, you must create and configure field security profiles that define which users or teams can create, read, or update that secured field.
Field security profiles act as containers for field permissions. Within each profile, you specify which secured fields the profile grants access to and what level of access (Create, Read, Update) is provided. Users or teams are then assigned to these profiles, and only those with the appropriate profile can access the secured field data. Without being assigned to a profile that grants access, users will see the field as empty or unavailable.
This security mechanism operates independently of table-level security and entity privileges. A user might have full access to a record but still be unable to view specific fields if they lack the appropriate field security profile. This granular control is essential for protecting sensitive data like salary information, social security numbers, or other confidential details.
A) Security roles control access to tables and records, not individual fields. While security roles are important for overall data access, they do not provide the granular field-level control needed for securing sensitive fields like salary information.
C) Setting a field’s requirement level to Business Required affects whether users must provide a value for the field before saving a record. It has no relationship to security or controlling who can view the field’s data.
D) Business rules can show or hide fields on forms based on conditions, but this is a client-side UI behavior that doesn’t prevent determined users from accessing the data through other means like APIs, reports, or views. True field-level security must be enforced at the platform level.
Question 8.
You are developing a solution that uses the Dataverse Web API to retrieve account records. You need to retrieve only accounts where the annual revenue is greater than one million dollars and return only the account name and revenue fields. Which Web API query should you use?
A) /api/data/v9.2/accounts?select=name,revenue& filter=revenue gt 1000000
B) /api/data/v9.2/accounts?filter=revenue > 1000000& select=name,revenue
C) /api/data/v9.2/accounts?query=revenue gt 1000000& return=name,revenue
D) /api/data/v9.2/accounts?where=revenue > 1000000& fields=name,revenue
Answer: A
Explanation:
The Dataverse Web API uses OData query conventions to filter and shape data. The correct syntax requires using the $filter system query option for filtering records and the $select system query option for choosing which fields to return. The comparison operator for «greater than» in OData is «gt» (not the > symbol), and the syntax must follow the OData v4.0 standard.
The $filter option allows you to specify criteria that records must meet to be included in the results. Common OData operators include eq (equals), ne (not equals), gt (greater than), ge (greater than or equal), lt (less than), and le (less than or equal). These operators must be used with the proper OData syntax rather than standard programming language operators.
The $select option reduces the amount of data returned by specifying only the fields you need. This improves performance by reducing payload size and network traffic. When using $select, you list the field logical names separated by commas. If you don’t use $select, the API returns all fields, which is inefficient when you only need specific data.
B) This option uses the incorrect comparison operator > instead of the OData operator gt. While this syntax might work in some programming languages, the Dataverse Web API requires proper OData syntax, and this query would result in an error.
C) The query options $query and $return are not valid OData system query options. The correct options are $filter for filtering records and $select for choosing fields. This query would fail because the Web API would not recognize these invalid parameters.
D) The query options $where and $fields are not valid OData system query options in the Dataverse Web API. Additionally, this uses the incorrect > operator instead of gt. The correct OData options must be used for the query to execute successfully.
Question 9.
You are creating a solution that includes multiple publishers. You need to ensure that your customizations do not conflict with customizations from other publishers. What should you use to uniquely identify your customizations?
A) Solution name
B) Publisher prefix
C) Display name
D) Schema name
Answer: B
Explanation:
The publisher prefix is a critical element in Dataverse that helps avoid naming conflicts when multiple solutions or publishers make customizations to the same environment. When you create a publisher, you specify a prefix (typically 3-8 characters) that is automatically prepended to the schema names of all customization components you create, including tables, fields, choices, and other solution components.
For example, if your publisher prefix is «contoso» and you create a custom field called «Department» on the Account table, the actual schema name would be «contoso_Department». This ensures that if another publisher with prefix «fabrikam» creates a field with the same display name, it would be «fabrikam_Department», preventing any naming conflicts at the schema level.
The publisher prefix also helps identify which organization or team created specific customizations when reviewing an environment. This is particularly important in managed solutions where multiple ISVs (Independent Software Vendors) might be installing their solutions in the same environment. The prefix provides clear ownership and traceability of customizations.
A) Solution name identifies the package of customizations but doesn’t prevent naming conflicts. Multiple solutions can exist with components that have the same names, and the solution name itself doesn’t get applied to individual component schema names.
C) Display name is what users see in the user interface and can be the same across different customizations from different publishers. Display names don’t need to be unique and therefore cannot prevent conflicts at the technical level.
D) Schema name is the technical name of a component, but without a publisher prefix, schema names from different publishers could conflict if they happen to use the same names for their customizations. The publisher prefix ensures schema name uniqueness.
Question 10.
You are developing a model-driven app and need to add custom business logic that runs when a user clicks a button on the command bar. Which type of component should you create?
A) Business rule
B) JavaScript web resource
C) Plugin registered on a custom action
D) Power Automate flow
Answer: B
Explanation:
JavaScript web resources are the appropriate solution for implementing custom business logic that responds to user interactions in model-driven apps, including command bar button clicks. Web resources are client-side script files that execute in the user’s browser and can interact with the form, manipulate data, call Web APIs, and provide immediate feedback to users.
When you create a custom button on the command bar in a model-driven app, you define a command that specifies which JavaScript function to call when the button is clicked. The JavaScript web resource contains this function and all the logic needed to perform the desired action. This could include validating data, opening custom dialogs, calling external services, updating related records, or navigating to different forms.
JavaScript web resources provide access to the Xrm.WebApi for interacting with Dataverse data, the formContext for accessing form data and controls, and various utility functions for common operations. They execute immediately in response to user actions, providing a responsive user experience without server round trips for the initial button click handling.
A) Business rules are declarative configuration tools that run automatically based on conditions like field changes or form loads. They cannot be triggered by custom command bar buttons and don’t support the level of custom logic needed for button click handlers.
C) While plugins can contain custom business logic, they execute on the server side in response to Dataverse messages like Create, Update, or custom actions. A plugin alone cannot directly respond to a command bar button click, though a JavaScript function could call a custom action that triggers a plugin.
D) Power Automate flows are designed for workflow automation and typically run asynchronously. They cannot directly respond to command bar button clicks in real-time. While a JavaScript function could trigger a flow, the flow itself is not the component that handles the button click event.
Question 11.
You need to optimize a plugin that retrieves related records from multiple tables. The plugin is experiencing performance issues. Which approach should you use to improve performance?
A) Use early-bound classes instead of late-bound classes
B) Retrieve all columns for each record to minimize queries
C) Use QueryExpression with ColumnSet specifying only needed columns
D) Register the plugin on PreValidation stage instead of PostOperation
Answer: C
Explanation:
Using QueryExpression with a ColumnSet that specifies only the columns you need is a critical performance optimization technique in plugin development. When you retrieve records from Dataverse, requesting all columns (using ColumnSet with AllColumns = true) returns significantly more data than necessary, increasing network traffic, memory usage, and processing time, especially when dealing with tables that have many columns or complex data types.
By explicitly specifying only the columns you need in the ColumnSet, you reduce the payload size, minimize the data transfer between the database and your plugin, and improve overall query performance. This is particularly important when retrieving related records from multiple tables, as the cumulative effect of inefficient queries can severely impact plugin execution time.
QueryExpression also provides additional optimization opportunities such as using LinkEntity to retrieve related records in a single query instead of making multiple separate queries, filtering records at the database level using FilterExpression, and limiting the number of records returned with TopCount. These techniques work together to create efficient data retrieval operations.
A) While early-bound classes provide compile-time type checking and IntelliSense support, they don’t significantly improve runtime performance compared to late-bound classes. Both approaches ultimately execute the same underlying queries and operations. The real performance gains come from optimizing the queries themselves, not the class binding approach.
B) Retrieving all columns for each record is actually the opposite of optimization and will significantly decrease performance. This approach increases network traffic, memory consumption, and processing time. You should always retrieve only the specific columns needed for your business logic.
D) Changing the plugin stage from PostOperation to PreValidation does not improve query performance and could introduce other issues. The stage determines when the plugin executes in the pipeline, not how efficiently it retrieves data. Query optimization is independent of the plugin registration stage.
Question 12.
You are implementing a solution that requires calling a custom action from a canvas app. The custom action contains business logic that must run on the Dataverse server. How should you call the custom action from the canvas app?
A) Use the Dataverse connector and call the action through the connector
B) Create a JavaScript web resource to call the action
C) Use Power Automate to create a flow that calls the action
D) Use the Office 365 Users connector
Answer: A
Explanation:
The Dataverse connector in canvas apps provides direct access to Dataverse functionality including the ability to call custom actions and APIs. When you add the Dataverse connector to your canvas app, you can access unbound actions (actions not tied to a specific table) and bound actions (actions associated with specific table records) directly through the connector’s interface.
Custom actions in Dataverse are essentially custom messages that encapsulate business logic on the server side. They can accept input parameters and return output parameters, making them ideal for complex business operations that need to run securely on the server. The Dataverse connector provides a type-safe way to call these actions, with IntelliSense support showing available actions and their parameters.
To call a custom action from a canvas app, you use the Environment function or directly reference the action through the connector, pass any required input parameters, and handle the returned output. This approach keeps the business logic centralized on the server while allowing canvas apps to trigger that logic when needed, maintaining good separation of concerns and security.
B) JavaScript web resources are used in model-driven apps for client-side customization and cannot be directly used in canvas apps. Canvas apps use a different architecture and don’t support loading JavaScript web resources from Dataverse.
C) While you could create a Power Automate flow that calls the custom action and then trigger that flow from the canvas app, this adds unnecessary complexity and latency. The Dataverse connector provides a more direct and efficient way to call custom actions without requiring an intermediary flow.
D) The Office 365 Users connector is specifically for accessing Office 365 user profile information and has nothing to do with calling Dataverse custom actions. This connector cannot interact with Dataverse business logic or custom actions.
Question 13.
You are developing a plugin that needs to access configuration data that varies between different environments (development, test, production). Where should you store this configuration data?
A) Hard-code the values in the plugin code
B) Store the values in the plugin’s secure configuration or unsecure configuration
C) Create custom tables to store the configuration
D) Use environment variables in the solution
Answer: D
Explanation:
Environment variables are the recommended modern approach for storing configuration data that varies between environments in Power Platform solutions. Environment variables allow you to define configuration values that can be different in each environment without modifying code or re-registering plugins. They are fully supported in solutions and can be easily managed through the Power Platform admin center or within the solution itself.
Environment variables can store various data types including text, numbers, JSON, and even data source references. When you export and import solutions between environments, you can specify different values for environment variables during the import process, making them perfect for scenarios where configuration needs to change between development, test, and production environments.
From a plugin, you can retrieve environment variable values using the Dataverse Web API or through the Organization Service by querying the environmentvariabledefinition and environmentvariablevalue tables. This approach provides flexibility, maintains security, and follows Microsoft’s recommended practices for solution development and application lifecycle management.
A) Hard-coding configuration values in plugin code is a bad practice that violates the principle of separation of configuration from code. It requires recompiling and redeploying the plugin whenever configuration changes, makes the code less maintainable, and can lead to errors when moving solutions between environments.
B) While secure and unsecure configuration parameters were the traditional approach for plugin configuration, they have limitations. They are set during plugin step registration and are less flexible than environment variables. Microsoft now recommends using environment variables instead for new developments.
C) Creating custom tables to store configuration is possible but adds unnecessary complexity. You would need to create tables, forms, security roles, and custom code to manage the configuration. Environment variables provide a built-in, standardized way to handle configuration without this overhead.
Question 14.
You need to create a virtual table in Dataverse that displays data from an external SQL database. The data should be read-only and retrieved in real-time. What should you implement?
A) Custom connector with Power Automate sync flow
B) Virtual table with a custom data provider
C) Azure Data Factory pipeline
D) Dual-write functionality
Answer: B
Explanation:
Virtual tables (formerly called virtual entities) in Dataverse allow you to surface data from external systems without actually storing that data in Dataverse. A virtual table with a custom data provider is the correct approach when you need to display real-time data from external sources like an external SQL database while maintaining read-only access.
A custom data provider is a plugin that implements specific interfaces (IPlugin and specific virtual table interfaces) to handle CRUD operations for the virtual table. For read-only scenarios, you would implement the Retrieve and RetrieveMultiple operations to fetch data from the external SQL database. The data provider acts as a bridge, translating Dataverse queries into queries against your external system and converting the results back into Dataverse-compatible format.
Virtual tables appear and behave like regular Dataverse tables in model-driven apps, views, and forms. Users can interact with virtual table records just like native Dataverse records, but the data is retrieved in real-time from the external source. This approach ensures data consistency without the need for synchronization, as every read operation fetches fresh data from the external system.
A) A custom connector with Power Automate sync flow would copy data from the external SQL database into Dataverse tables, which doesn’t meet the requirement for real-time read-only access. This approach creates data duplication and requires ongoing synchronization, which is inefficient for read-only scenarios.
C) Azure Data Factory is designed for ETL (Extract, Transform, Load) operations and batch data integration. It would copy data into Dataverse rather than providing real-time access. This doesn’t meet the requirement for displaying real-time read-only data without storage in Dataverse.
D) Dual-write functionality is specific to Dynamics 365 Finance and Operations apps and is used to synchronize data bidirectionally between Finance and Operations and Dataverse. It’s not applicable for connecting to external SQL databases or for general-purpose virtual table scenarios.
Question 15.
You are building a canvas app that needs to display a hierarchical organizational chart. The organizational data is stored in Dataverse with a self-referencing relationship. Which control should you use in the canvas app?
A) Gallery control with nested galleries
B) Tree view PCF control
C) Data table control
D) Dropdown control
Answer: B
Explanation:
A tree view PCF (PowerApps Component Framework) control is specifically designed for displaying hierarchical data structures like organizational charts. PCF controls are custom components that extend the standard controls available in Power Apps, and several tree view controls are available in the PCF gallery or can be custom-built to meet specific requirements.
Tree view controls are optimized for handling hierarchical relationships where records reference parent records in the same table (self-referencing relationships). They provide a visual representation that allows users to expand and collapse nodes, navigate through hierarchy levels, and understand reporting structures at a glance. This type of control is ideal for organizational charts, file system structures, category hierarchies, and similar tree-structured data.
For organizational charts specifically, there are purpose-built PCF controls and third-party solutions that can render the data in various formats including traditional tree structures, left-to-right hierarchies, or graphical org chart layouts. These controls handle the complexity of recursive data relationships and provide user-friendly navigation through potentially deep hierarchies.
A) While you could technically use nested galleries to display hierarchical data, this approach becomes extremely complex and performs poorly with deep hierarchies. Galleries are designed for flat lists, and nesting them creates maintenance challenges, performance issues, and doesn’t provide the intuitive expand/collapse functionality users expect from hierarchical displays.
C) Data table controls are designed for displaying tabular data in rows and columns, similar to a spreadsheet. They don’t provide any built-in support for visualizing or navigating hierarchical relationships. While you could display the data in a flat table format, this doesn’t give users the visual understanding of the organizational structure.
D) Dropdown controls are for selecting a single value from a list of options. They are completely inappropriate for displaying complex hierarchical organizational structures where users need to see multiple levels and relationships simultaneously. Dropdowns don’t provide any visualization of hierarchy or relationships.