Crack Your Power Platform Interview: Canvas, Model-Driven & Automate

Power Platform Interview Guide

Scenario-Based Questions: Power Apps, Dataverse & Power Automate

Part 1 Power Apps (Canvas & Model-Driven)

1. Your Canvas app is slow when loading a gallery with large data. How will you optimize performance?

• Use delegation with Filter() instead of Search().
• Implement pagination using FirstN() or Last().
• Add search/filter controls to limit the initial data load.
• Use ClearCollect() to cache data locally.
• Ensure DelayItemLoading is set to true.
• Reduce the number of controls inside the gallery template.

2. You need to insert or update multiple records at once from a gallery. How will you implement this?

• Use the ForAll() function combined with Patch().
• Collect changes in a local collection first to minimize chatter.
• Use Patch(DataSource, Collection) for efficient bulk operations.
• For very large volumes, pass the collection (JSON) to a Power Automate flow.

3. User-entered data is lost when navigating between screens. How will you fix this?

• Store data in global variables using Set().
• Use collections with ClearCollect() or Collect().
• Pass context variables explicitly using Navigate(Screen, Transition, {Var: Value}).
• For forms, utilize the Form.Updates property before navigation.

4. Only logged-in users should see their own records. How will you implement this?

• Canvas: Filter data source: Filter(DataSource, Owner = User().Email).
• Dataverse: Configure security roles and record ownership (Basic/User level access).
• Use Field-Level Security for masking sensitive fields.
• Implement Business Units for organizational hierarchy isolation.

5. The same form must support Create, Edit, and View modes. How will you design it?

• Utilize the Form.Mode property (New, Edit, View).
• Set DisplayMode conditionally: If(Form.Mode = FormMode.View, DisplayMode.View, DisplayMode.Edit).
• Toggle Edit/Submit button visibility based on the mode.
• Use the OnSuccess property to navigate or notify after submission.

6. The app must work offline. What approach will you follow?

• Use SaveData() and LoadData() for local device storage.
• Cache necessary data in collections during App.OnStart.
• Use Connection.Connected to detect internet availability.
• Sync changes when back online using a loop with Patch().

7. How will you prevent duplicate record creation in a Canvas app?

• Check existing records before insert: If(IsEmpty(Filter(...)), Patch(...)).
• Use CountRows() to validate uniqueness logic.
• Implement Dataverse Alternate Keys (Server-side enforcement).
• Add duplicate detection rules in Dataverse settings.

8. Different users should see different buttons or controls on the same screen. How will you manage this?

• Use the Visible property logic based on variables.
• Hardcode (not recommended for scaling): User().Email in ["admin@company.com"].
• Query Dataverse security roles or a custom "User Permissions" table.
• Store permissions in a global variable on app start for performance.

9. When do you prefer using collections instead of direct data source operations?

• For offline scenarios.
• When data needs complex manipulation/math before display.
• To improve performance by reducing repeated API calls.
• When working with non-delegable functions to avoid limits.
• When joining/combining data from multiple different sources.

10. When would you choose a Model-Driven app over a Canvas app?

• Complex data models with deep relationships.
• When built-in security, role-based access, and audit features are primary.
• Business Process Flows (BPF) are a core requirement.
• Need for advanced dashboarding, views, and charts out-of-the-box.
• Development speed matters more than pixel-perfect UI customization.

11. A user cannot see records even though data exists. How will you troubleshoot this?

• Check Security Roles and permissions assigned to the user.
• Verify record ownership and sharing status.
• Review Business Unit hierarchy (is the user in a different BU?).
• Check Column-Level Security settings.
• Validate filter conditions in the App (Views or Gallery Items property).

12. A field should be mandatory only for certain statuses. How will you implement this?

• Model-Driven: Use Business Rules to toggle "Required" level.
• Canvas: Set the Required property: Status.Value = "Approved".
• Use Power Automate or Plugins for backend validation to ensure data integrity.

13. You must prevent deletion of records once they are approved. How will you design this?

• Best Practice: Use a synchronous Plugin on the Delete event to validate status.
• Configure Security Roles to remove the "Delete" privilege for general users.
• Use JS (Model-Driven) or Visible property (Canvas) to hide the delete button.

14. What happens if two users edit the same record at the same time?

• Default behavior: "Last save wins."
• Use Optimistic Concurrency (ETag) to detect conflicts.
• Implement versioning in the data source.
• Use a Plugin to implement custom conflict resolution logic.

Part 2 Dataverse

15. How will you implement row-level security in Dataverse?

• Assign record ownership (User/Team owned tables).
• Configure Security Roles (Create, Read, Write, Delete, etc.) at distinct levels (User, BU, Parent-Child BU, Org).
• Use "Record Sharing" for ad-hoc exceptions.
• Implement Access Teams for lightweight dynamic sharing.

16. How do you prevent duplicate records at the database level?

• Create **Alternate Keys** on unique fields (this enforces uniqueness).
• Configure **Duplicate Detection Rules** and enable them for Create/Update events.
• Use Plugins (Pre-Validation stage) for complex logic checks.

17. What happens to child records when a parent record is deleted?

This depends on the Relationship "Cascade" behavior settings:

• Cascade All: Deletes all child records automatically.
• Cascade Active: Deletes only active child records.
• Remove Link: Keeps records but nullifies the lookup to the parent.
• Restrict: Prevents deletion of the parent if children exist.

18. Business logic must apply to Canvas apps, Model-Driven apps, and APIs. Where will you implement it?

• Dataverse Business Rules: For simple logic (Scope = Entity).
• Plugins: For complex, server-side logic (ensures logic runs regardless of the entry point).
• Never rely solely on client-side logic (Canvas formulas or JavaScript) if the API is exposed.

19. When would you choose Plugins over Power Automate?

• When synchronous execution (real-time) is required.
• Validation scenarios where you need to prevent/rollback the save operation.
• High-performance requirements (Plugins are faster than Flows).
• Pre-operation changes (modifying data before it hits the database).

Part 3 Power Automate

20. You need to trigger a flow only for specific field updates. How will you design this?

• Use the Dataverse trigger "When a row is added, modified or deleted".
• In the trigger settings, use Select Columns to define which fields trigger the flow.
• Use Trigger Conditions (e.g., @not(equals(triggerOutputs()?['body/status'], 'Active'))).

21. A flow is slow because it processes thousands of records. How will you optimize it?

• Use Batch/Pagination settings on "List rows" actions.
• Avoid "Apply to Each" loops if possible; use Filter Query in the API call (OData).
• Enable Concurrency Control in the "Apply to Each" settings to run in parallel.
• Use Child Flows to offload processing.

22. How do you avoid infinite loops when a flow updates the same data source it is triggered from?

• Use Trigger Conditions to check if the 'Modified By' is not the service account running the flow.
• Example: @not(equals(triggerOutputs()?['body/_modifiedby_value'], 'GUID-OF-FLOW-USER')).
• Use specific column filtering so the flow doesn't trigger on its own updates.

23. You need to send approval reminders on the 5th working day. How will you design this?

• Create a Scheduled Cloud Flow that runs daily.
• Filter for records pending approval > 5 days.
• Use expressions like dayOfWeek() to calculate business days (excluding Sat/Sun).
• Alternatively, use a "Do Until" loop with delays (less recommended for long durations).

24. How will you handle errors and retries in Power Automate?

• Use the Configure Run After setting (runs if failed/timed out).
• Implement a Try-Catch-Finally pattern using Scope actions.
• Log errors to a dedicated table or send notification emails to admins.
• Configure standard retry policies in the action settings (Fixed Interval vs Exponential).

25. When would you use parallel branches and what are their limitations?

• Use case: Independent tasks (e.g., getting data from SQL and SharePoint simultaneously).
• Limitation: You cannot easily share variables between branches without initializing them globally.
• Limitation: Troubleshooting execution order can be complex if one branch fails.

26. How do you design a flow that runs only on business days?

• Add a Trigger Condition: @and(not(equals(dayOfWeek(utcNow()), 0)), not(equals(dayOfWeek(utcNow()), 6))).
• Or check against a custom "Holiday/Business Calendar" table inside the flow logic.

27. When do you use child flows instead of a single large flow?

• For Reusable Logic (DRY principle).
• To simplify huge, complex flows (modularity).
• To bypass action limits in a single flow run.
• To run tasks with different connection privileges (Run-only user settings).

28. How do you manage environment-specific values in Power Automate?

• Use Environment Variables in Dataverse Solutions.
• Store config data in a dedicated SharePoint List or Table and query it.
• Avoid hardcoding URLs or IDs; reference dynamic values.

29. How do you secure Power Automate flows and connections?

• Use Service Principals or Service Accounts rather than personal credentials.
• Enforce DLP Policies at the environment level.
• Restrict "Run-only user" permissions.
• Use Azure Key Vault to store secrets/passwords and fetch them in the flow.