Reusable form UI and client-side code in model-driven apps
Short answer
BE Use a JavaScript web resource for client-side form extension and a Power Apps component framework control for reusable custom UI components.
Question
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the “Next” button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions. When you are ready to answer a question, select the “Question” button to return to the question.
Background
Fabrikam Inc. is an energy provider that operates wind and solar farms across multiple countries and regions. The company uses Microsoft Power Platform to manage asset maintenance, technician workflows, and predictive analytics.
Field technicians use canvas apps on mobile devices to capture inspection and repair data. Operations managers use model-driven apps to monitor asset performance and maintenance history.
The company plans to enhance its platform by introducing AI-driven insights, improving reuse across applications, and establishing a formal application lifecycle management (ALM) strategy.
Current environment
Applications
Field technicians use an outdated mobile app to log maintenance activities and capture asset readings in SharePoint Online.
Operations managers use a model-driven app to review maintenance records and asset performance trends.
Development practices
Developers build and modify applications directly in the production environment.
There is NO structured ALM process.
Solutions are NOT consistently used to package or deploy application components.
Reusable components are inconsistently implemented across apps, leading to duplication.
AI integration
Fabrikam Inc. plans to actively explore generative AI usage as part of the next phase of work.
Business requirement
Application development
The outdated mobile app must be replaced with a new app that supports responsive design principles, provides full control over the UI, and allows technicians to take and upload photos directly from their mobile devices.
The new app for the field technicians requires the name of the technician to be persisted on the home screen only. In addition, work orders must be displayed within a gallery.
All new apps must connect to a scalable, cloud-based relational data store.
Apps must support efficient data entry for technicians in the field.
Reusable UI elements must be implemented to reduce duplication.
AI capabilities
The company requires a generative AI solution to manage customer complaint responses and create custom inspection reports that align to an existing template.
Customer complaint responses must be generated in applications and based on emails being sent to a mailbox.
Custom AI development must be minimized.
Generative AI reusability
Generative AI solutions must accept dynamic inputs to adapt to different scenarios.
Generative AI solutions must be reusable across different Power Platform services.
Extensibility
Custom UI form components must be reusable across applications.
Use of server-side custom code must be minimized where possible.
Technical requirements
Application lifecycle management (ALM)
Separate environments must be used for development, testing, and production.
Solutions must be used to package application components, segmented based on functional areas.
Managed solutions must be deployed to the production environment.
Validation must occur before deployment to production.
Data processing
Aggregated values across related rows must be displayed for reporting.
Calculations must update automatically as new data is entered. Calculation data must be limited to a maximum length of 10.
Issues
Duplicate logic exists across multiple canvas apps.
Developers frequently overwrite changes in production.
Generative AI solutions produce inconsistent outputs due to missing or inconsistent inputs.
Maintenance metrics are not consistently calculated across related rows.
You need to implement the extensibility requirements.
Which two options should you use? Each correct answer presents part of the solution.
NOTE: Each correct selection is worth one point.
Key Takeaways
The question tests matching extensibility needs to client-side versus server-side execution and reusable UI mechanisms, with plug-ins as the main server-side trap.
This AB-410 case study tests extensibility choices for model-driven apps: use a JavaScript web resource to avoid server-side code and a Power Apps component framework control for reusable custom UI. The correct selections are B and E.
Common mistake: A common trap is choosing D (plug-in) because it extends model-driven apps, but plug-ins are server-side code, which the case explicitly wants minimized; C (business rule) adds logic but cannot provide reusable custom UI form components.
Expert Analysis
Requirement split. The extensibility requirement has two distinct clauses. 'Custom UI form components must be reusable across applications' points to a packaged UI component, not a sitemap or declarative rule. 'Use of server-side custom code must be minimized where possible' points to client-side form logic instead of a Dataverse plug-in. That makes B and E the coherent pair: JavaScript web resources extend model-driven forms without server-side execution, and Power Apps component framework (PCF) controls deliver reusable custom UI form components.
Why B fits. A JavaScript web resource is uploaded to Dataverse and attached to form events or ribbon commands. It runs in the client browser, so routine form behavior can be implemented without writing a plug-in that executes on the server. In this case, that directly answers the minimize-server-side-code constraint. The requirement is not 'no code'; it is to avoid server-side custom code where possible, and B is the option that moves extension logic to the client. A common comment rationale makes the same link: JavaScript allows client-side customization and reduces reliance on plug-ins.
Why E fits. PCF controls package custom UI as reusable components. They can be configured on model-driven forms and also surface in canvas apps, which addresses the repeated duplication problem across Fabrikam's applications. E is not just a custom control for one form; it is the extensibility mechanism intended for reusable custom UI. Operational consequence: choosing a one-off form customization would keep duplication, while PCF centralizes the UI and reduces maintenance drift.
Wrong options and adjacent decision. D (plug-in) extends Dataverse with server-side code, so it conflicts with the explicit minimize-server-side requirement. C (business rule) is declarative logic, but it does not provide reusable custom UI form components. A (sitemap) only controls navigation and cannot satisfy either clause. A scenario change could flip the answer: if the requirement demanded server-side validation that must run regardless of client, a plug-in could become appropriate. But here, the paired constraints make B and E the correct selection. If server-side code could not be avoided for integration, D would enter consideration, but it would still not satisfy the reusable UI requirement. Getting this wrong increases server-side maintenance and leaves custom UI duplicated.
Official Reference
- https://learn.microsoft.com/en-us/power-apps/developer/component-framework/overview
- https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/reference
- https://learn.microsoft.com/en-us/power-apps/developer/data-platform/webresource
These links open the official vendor documentation in a new tab.
Exam Strategy
When a case study says to minimize server-side code and make custom UI reusable, classify each option by execution location and reuse scope: JavaScript web resources run client-side in forms, PCF controls package reusable UI, plug-ins are server-side, and business rules are declarative logic. Read both extensibility bullets together; one option must satisfy the UI-reuse requirement and the other must satisfy the minimize-server-code requirement. Eliminate any option that cannot be deployed as a reusable component or that adds server-side execution.
Frequently Asked Questions
Why is a plug-in not selected when the case asks to minimize server-side custom code?
How does a Power Apps component framework control meet the reusable UI requirement?
What would make a plug-in the right choice in this scenario?
Discussion 3 contributions
Compiled from public community threads and reader submissions, lightly edited for clarity. Handles and vote tallies are shown as recorded, and comments reflect the views of individual contributors.
From public community threads 3
-
427ea93 👍 3I think B and E are more correct.
-
philipssujin 👍 1B. JavaScript web resource: Allows client-side customization in model-driven apps, minimizing the need for server-side custom code such as plug-ins. E. Power Apps component framework control: Enables developers to create reusable custom UI components that can be used across multiple applications.
-
exam_upskill 👍 1B. JavaScript web resource E. Power Apps component framework control
Reader comments & corrections
No reader corrections yet — spotted an error or have a note? Share it below.