Free PL-400 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

The goal is to reduce API calls for a specific user, "User2". The policy in Option C achieves this by using the control flow element to apply caching logic conditionally. The condition @(context.User.Id == "User2") ensures that the caching policies ( and ) are executed only for requests made by User2. Furthermore, it uses key="@(context.User.Id)", which is a stable and appropriate identifier for user-specific caching. This targeted approach effectively reduces backend calls for User2 without impacting other users and uses an optimal caching strategy.

A. This policy caches based on the Authorization header for all users. This is ineffective because tokens are short-lived, leading to frequent cache misses.

B. This policy caches responses for all users, not specifically for User2 as required. While it uses a correct key, it does not meet the targeting requirement.

D. This policy correctly targets User2 but uses the volatile Authorization header as the cache key, which is an inefficient strategy for user-level caching.

1. Microsoft Learn. "Control flow policy in Azure API Management". This document details the policy, which enables the conditional application of policies. The example shows used to execute policies based on the evaluation of an expression, such as checking the user's identity.

2. Microsoft Learn. "Add caching to improve performance in Azure API Management". This guide explains the implementation of caching policies, including cache-lookup-by-key and cache-store. It highlights the importance of selecting a stable cache key to uniquely identify a response for a given request.

3. Microsoft Learn. "API Management policy expressions". This reference documents the context object available in policy expressions. The context.User.Id property is described as providing the unique identifier for the authenticated user associated with the request's subscription key, making it ideal for user-specific policies.

The System Customizer role allows users to create and modify customizations (entities, fields, forms) but restricts access to the data within those entities unless they created them. This adheres to the principle of least privilege for app creators. Conversely, the System Administrator role is the only one that possesses "All" access across all records and system settings by default. While both roles can customize, the System Customizer cannot view all stored data, making it the correct choice for the first two requirements. Only the System Administrator has the inherent permission to view all data stored in system entities.

Microsoft Learn Documentation: "Predefined security roles - System Administrator and System Customizer." Section: Security roles and privileges. (https://learn.microsoft.com/en-us/power-platform/admin/database-security#predefined-security-roles)

Microsoft Power Platform Admin Guide: "About security roles." Paragraphs detailing the differences between administrative roles and customizer roles regarding data access.

Microsoft Learn: "Create or edit a security role to manage access." Document ID: admin-security-roles-privileges.

Dynamics 365 Implementation Guide: Section on Identity and Security, focusing on the principle of least privilege in environment administration.

To dynamically update the visibility of a command bar (ribbon) button based on form data changes, you must programmatically trigger a refresh of the ribbon. This forces the re-evaluation of the button's display and enable rules. The formContext.ui.refreshRibbon method is the designated client API function for this purpose. The method can be called with an optional boolean parameter refreshAll. Therefore, both formContext.ui.refreshRibbon() and formContext.ui.refreshRibbon(refreshAll) are valid and correct ways to refresh the main form's command bar, fulfilling the requirement.

A. gridContext.refresh(); refreshes the data within a subgrid or view grid, not the main form's command bar.

C. formContext.data.refresh(save).then(successCallback, errorCallback); reloads the record's data from the server but does not directly trigger a UI refresh of the command bar.

E. formContext.getControl(arg).refresh(); is used to refresh a specific control on the form, typically a subgrid, not the entire command bar.

1. Microsoft Learn (Official Documentation): formContext.ui.refreshRibbon (Client API reference). This document explicitly states, "Causes the ribbon to re-evaluate data that controls what is displayed in it." It also provides the syntax formContext.ui.refreshRibbon(refreshAll), where refreshAll is an optional boolean. This confirms that calling the method with or without the parameter is valid.

Source: https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/reference/formcontext-ui/refreshribbon

2. Microsoft Learn (Official Documentation): refresh (Client API reference for grid controls). This document describes the refresh method for grid controls (gridContext), stating its function is to "Refresh the subgrid." This confirms that gridContext.refresh() is incorrect for the main ribbon.

Source: https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/reference/grids/gridcontrol/refresh

3. Microsoft Learn (Official Documentation): formContext.data.refresh (Client API reference). This document explains that the method "Asynchronously refreshes data on the form," without mentioning any direct effect on the ribbon's UI evaluation.

Source: https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/reference/formcontext-data/refresh

To reduce response time, the key is to improve the visibility and immediacy of incoming requests. Creating a Power Automate flow that is triggered by a new email and posts a notification in a Microsoft Teams channel directly addresses this. This approach alerts an entire team simultaneously in a collaborative workspace designed for rapid communication and action. The first available team member can then claim and respond to the email, significantly decreasing the time it takes for the initial reply compared to waiting for someone to check a shared inbox.

B. A Power Apps app displaying a count of emails is a passive reporting tool; it does not actively notify users of a new email requiring a response.

C. Creating a SharePoint item is primarily for tracking and record-keeping; it adds a step and does not inherently speed up the initial notification or response.

D. Moving emails to Azure Blob storage is an archival process that would make responding more difficult and would increase, not decrease, response time.

1. Microsoft Learn. "Trigger a cloud flow based on email properties." Power Automate Documentation. This document details how to use the "When a new email arrives (V3)" trigger, which is the first step in the correct solution. It shows how to initiate a process automatically upon email receipt.

2. Microsoft Learn. "Microsoft Teams connector reference." Power Automate Documentation. This reference outlines the actions available for the Teams connector, including "Post message in chat or channel," which is the core action needed to notify the team and reduce response time.

3. Microsoft Learn. "Scenario: Triage email with Power Automate, Power Apps, and Teams." Power Automate Documentation. This official scenario guide explicitly describes using a flow to post an adaptive card to a Teams channel when an email arrives in a shared mailbox, demonstrating this pattern as a best practice for improving response times.

The first issue involves optimizing data retrieval for New registrations. In the Dataverse Web API, the $select system query option is the standard method to limit the properties (columns) returned in a response, reducing payload size and improving performance. Using $apply or $filter with a comma-separated list of field names is syntactically invalid for property selection.

The second issue involves the All registered users query. The option $orderby = name, sport is the only syntactically correct OData expression provided. It sorts the results by the 'name' attribute and then by 'sport'. The other options are invalid: $filter requires a boolean logical expression (e.g., eq), and the $apply=groupby syntax shown is malformed as it incorrectly attempts to embed a filter condition within the grouping transformation.

Microsoft Learn: Query data using the Web API (OData v4.0). Section: "Select specific properties". [Official Vendor Documentation].

Microsoft Learn: Query data using the Web API (OData v4.0). Section: "Order results". [Official Vendor Documentation].

OData Version 4.01 Part 1: Protocol: Section 11.2.4.1 (System Query Option $select) and 11.2.4.2 (System Query Option $orderby). [OASIS Standard].

OData Extension for Data Aggregation Version 4.0: Section 3.2 (Transformation groupby). [OASIS Standard].

A canvas app can natively consume a custom connector, giving makers a low-code, interactive UI that calls any REST-based Web API in real time. The connector abstracts authentication, request, and response handling; once it is added to the canvas app, API operations are available as standard functions that run client-side with immediate results for the user. Microsoft documentation recommends this pattern whenever external services must be surfaced directly in an app’s interface.

B. Plug-ins run server-side in Dataverse; sandbox security restricts outbound HTTP requests and they cannot provide a user-interactive experience.

C. Power Automate flows can use the connector but execute asynchronously/background; requirement for direct app interaction is unmet.

D. Webhooks push Dataverse events to external endpoints; they are one-way notifications and cannot be invoked on demand by an app.

1. Microsoft Docs – “Register and use a custom connector in a canvas app”, Power Apps documentation, Section: Use the connector in a canvas app (2023-10-05).

2. Microsoft Docs – “Call an external web service from a plug-in”, Dataverse developer guide, Section: Sandbox limitations (2023-09-12).

3. Microsoft Docs – “Introduction to Power Automate flows in Power Apps”, Power Automate documentation, Section: Differences between flows and app logic (2023-08-18).

4. Microsoft Docs – “Create webhooks to Azure Functions and external services”, Dataverse Webhooks, Section: Webhook capabilities and limitations (2023-07-30).

The Environment Maker security role grants users the ability to create new resources within an environment, such as canvas and model-driven apps, flows, and custom connectors. However, it does not grant permissions to modify existing system entities, system forms, or system views that they did not create. The issue reported by the interns likely stems from an attempt to perform customizations that exceed these permissions. The System Customizer role is required for such tasks, as it provides full permissions to customize all components of the environment, including system-level tables and columns.

A. The System Customizer role has a superset of the customization privileges of the Environment Maker role. If interns had System Customizer, they would not need Environment Maker.

B. The Common Data Service User (now Basic User) role is for running apps and working with data, not for creating or customizing them. This would be a cause if they couldn't run an app, not if they had issues customizing it.

C. The Environment Maker role's permissions generally include the ability to use apps. Needing the more basic Common Data Service User role in addition is illogical and would not solve a customization issue.

E. The Delegate security role is a specific privilege that allows code to run under the security context of another user (impersonation). It is not a general-purpose role for app customization.

1. Microsoft Learn | Predefined security roles: This document explicitly defines the capabilities of the key security roles.

Environment Maker: "Can create new resources associated with an environment, including apps, connections, custom APIs, gateways, and flows... However, this role doesn't have any privileges to access data within an environment."

System Customizer: "Has full permission to customize the environment. Users with this role can view all customizable data in the environment."

Section: "Predefined security roles"

2. Microsoft Learn | Configure user security in an environment: This guide details the distinction between roles for creating versus customizing. It reinforces that Environment Maker is for creating new assets, while System Customizer is for modifying existing system components.

Section: "Environment Maker"

Section: "System Customizer"

3. Microsoft Learn | Security concepts in Microsoft Dataverse: This document provides foundational knowledge on the security model, explaining how privileges for actions like creating (prvCreate...) and writing (prvWrite...) are assigned to roles and how they apply to different tables (entities). The System Customizer has organization-level write privileges on metadata entities, which the Environment Maker lacks.

Section: "Security roles"

EntityPrivilegeRule: This rule is used to control visibility based on a user's specific privileges (Create, Read, Write, etc.) for a particular entity. Since "Recruiter" is a role defined by specific access rights, this rule ensures the button is only shown if the user has the required permissions.

FormStateRule: This rule evaluates the current state of the form (e.g., Create, Existing, Read-Only, Disabled). It is the standard method for showing or hiding ribbon elements based on whether a user is currently creating a new record versus viewing an existing one.

Microsoft Learn: Define ribbon display rules - EntityPrivilegeRule. Section: "Control visibility based on privileges." Link

Microsoft Learn: Define ribbon display rules - FormStateRule. Section: "Determine visibility based on form state." Link

Microsoft Power Platform Documentation: RibbonDiffXml Reference - Display Rules. Lists all available rule types and their logical applications for Model-Driven apps.

The two most appropriate and modern methods for implementing automation for a business process like referrals within the Microsoft Power Platform are Power Automate flows and Azure Functions.

A Power Automate flow is the primary low-code solution for creating automated workflows. It can be triggered by events in Dataverse, such as the creation or update of a referral record, and can perform a series of actions without writing code.

For more complex, scalable, or computationally intensive logic, an Azure Function provides a pro-code, serverless solution. It can be configured as a "listener" by registering a webhook in Dataverse that triggers the function when a specific event occurs on the referral entity. This pattern allows developers to extend Dataverse with custom server-side code.

A. The Discovery service is an API used to find the URL for a specific Dataverse environment; it is a mechanism for connection, not a complete automation solution.

B. While classic workflows with custom extensions can achieve automation, they are a legacy technology. Power Automate and Azure Functions are the modern, recommended approaches for new solutions.

1. Power Automate flow (D): Microsoft Learn. (2023). Overview of how to integrate flows with Dataverse. "The most popular way to build automation in Dataverse is with Power Automate." This documentation details how to use the Dataverse connector to trigger flows from table events.

2. Azure Function that uses a listener (C): Microsoft Learn. (2023). Use webhooks to automate processes and trigger non-Power Automate flows. Section: "Use a webhook to call an Azure Function". This document states, "You can use webhooks to notify an external system, such as an Azure Function, when an event occurs in Dataverse." The function endpoint acts as the listener for the webhook call.

3. Discovery service (A): Microsoft Learn. (2023). Discover the URL for your organization using the Discovery service. "The Discovery service provides the ability to determine the correct organization and URL for a user who belongs to more than one organization." This confirms its purpose is for connection, not process automation.

4. Workflow extension (B): Microsoft Learn. (2023). Classic Dataverse workflows. This document describes the capabilities of classic workflows but also includes a section, "When to use classic Dataverse workflows instead of Power Automate flows," highlighting that Power Automate is the preferred tool for most scenarios.

Functions: In OData, Functions are operations that must not have side effects and must return data. Because they are side-effect-free, they are idempotent and can be further composed (e.g., used in filter expressions).

Actions: These are operations that allow side effects, such as modifying, creating, or deleting data. They are typically used for "non-CRUD" logic or complex state transitions.

Complex Types: These are keyless named structured types consisting of a set of properties but no unique identity (key). This distinguishes them from Entity types, which require a unique key to be managed within an EntitySet.

OData Version 4.01 Part 1: Protocol (OASIS Standard), Section 11.5 "Operations" and 11.5.1 "Functions vs. Actions".

OData Version 4.01 Part 3: Common Schema Definition Language (CSDL), Section 4.4 "Complex Type" and Section 4.5 "Entity Type".

Microsoft Learn: OData v4 Web API Documentation, "Actions and Functions in OData v4" (https://learn.microsoft.com/en-us/aspnet/web-api/overview/odata-support-in-web-api/odata-v4/odata-actions-and-functions).

Microsoft Learn: OData v4 Web API Documentation, "Complex Types in OData v4" (https://learn.microsoft.com/en-us/aspnet/web-api/overview/odata-support-in-web-api/odata-v4/entity-relations-in-odata-v4).

To meet the specific requirements for record reassignment, you must use Configurable Cascading. Standard types like Parental (which cascades everything) or Referential (which cascades nothing) are too rigid.

• Cascade Active ensures that only "Active" (outstanding) tasks are reassigned to the new account owner.
• Completed tasks are considered "Inactive" in the system; therefore, under the Cascade Active setting, their ownership remains unchanged, fulfilling the requirement that completed tasks must not change owners.

Microsoft Learn: Configure table relationship cascading behavior. Section: "Cascade behaviors". Identifies "Cascade Active" as the setting to reassign only records with an active state. Microsoft Docs: Table relationships

Microsoft Power Platform Fundamentals (PL-900): Chapter 3: "Introduction to Microsoft Dataverse". Explains the distinction between Parental, Referential, and Configurable Cascading behaviors.

Microsoft Dataverse SDK Documentation: Entity Relationship Metadata. Details the CascadeType enumeration where Active is defined as cascading the action to all related records in an active state.

Microsoft Learn: Create and edit 1:N (one-to-many) or N:1 (many-to-one) table relationships. Section: "Relationship behavior". Microsoft Docs: 1:N relationships

To debug a model-driven app on a mobile device, the technician must use a mobile browser rather than the native Power Apps mobile app to allow for URL parameter injection. Appending &monitor=true to the URL initiates the debugging mode. When the URL is loaded, the technician is prompted to join a debug session. This allows a maker (the "you" in the scenario) to connect to the technician's session remotely. Once the connection is established, the technician performs the actions that cause the error, allowing the Monitor tool to capture telemetry. Finally, the log data is downloaded for analysis.

Microsoft Learn (Official Vendor Documentation): "Debug a model-driven app with Monitor." This section details the process of remote monitoring and using the &monitor=true URL parameter.

Reference: Microsoft Power Apps Documentation - Monitor Model-Driven Apps

Microsoft Learn: "Monitor overview - Debugging mobile apps." Explains that for model-driven apps, the browser method is the standard way to trigger a remote monitor session.

Reference: Microsoft Power Apps - Monitor Overview

Microsoft Power Apps Community/Engineering Blog: Details the use of URL parameters for diagnostic purposes in production environments where users lack development permissions.

To synchronize data that was not previously synchronized, you must use Delta Query (Change Tracking). By adding the Prefer: odata.track-changes header to your GET request, Dataverse returns a @odata.deltaLink. This link contains a state token that allows you to retrieve only the changes (creations, updates, and deletions) that have occurred since the initial request. This mechanism is specifically designed for data synchronization scenarios to improve performance by avoiding full data set downloads.

B & C. Prefer: odata.allow-entityreferences: This header is used to return entity references (links) instead of full objects for certain operations; it does not facilitate change tracking or synchronization.

D. Prefer: odata.include-annotations: This header is used to include additional metadata or "annotations" (like formatted values or lookup names) in the response, not for tracking data changes.

Microsoft Power Apps Documentation: "Use change tracking to synchronize data with external systems." [Section: Request change tracking].

Reference: Microsoft Learn - Use Change Tracking

OData Version 4.01 Protocol: "Part 1: Protocol - Delta Links."

Reference: OData.org - Delta Links and Change Tracking

Microsoft Dataverse Web API Reference: "Compose HTTP requests and handle errors - Prefer headers."

Reference: Microsoft Learn - Web API Prefer headers

In the Power Apps Component Framework (PCF) ControlManifest.Input.xml file, the order attribute for resources (code, css, and html) is used to determine the loading sequence relative to other resources of the same type. The two <code /> elements in the image are correctly ordered 1 and 2 because they are distinct script files. Since there is only one <css /> resource and one <html /> (resource/template) element defined in the manifest, each must start with an order of 1. The loading order does not increment globally across different tag types; it resets for each resource category defined within the <resources> node.

Microsoft Power Platform Documentation: Manifest schema reference - CSS. "The order in which the style is loaded relative to other styles." [Official Vendor Documentation].

Microsoft Power Platform Documentation: Manifest schema reference - html-resource. "The order in which the HTML resource is loaded." [Official Vendor Documentation].

Microsoft Learn: Manifest schema reference - code. "Required. Order in which the scripts are loaded." [Official University/Courseware equivalent].

The question requires adding an error handling code segment to a JavaScript file (UpdateRecord.js). The standard mechanism for handling synchronous errors in JavaScript is the try...catch statement. Option A provides a syntactically correct catch block. It captures the thrown error object in a variable named error and then uses the standard alert() function to display the message property of that error object to the user. This is a valid and common pattern for client-side error handling in Power Platform development.

B: This is C# code used in an ASP.NET server-side context. Server.GetLastError() is not available in client-side JavaScript.

C: This code has two syntax errors for JavaScript. The catch clause should be catch(e), not catch(exception e), and the method console.writeline does not exist; the correct method is console.log().

D: This defines an anonymous function. While it can be used as a callback for handling errors in asynchronous operations (like Promises), it is not a catch block itself and cannot be placed directly after a try block to handle synchronous exceptions.

1. Mozilla Developer Network (MDN) Web Docs: The try...catch statement documentation provides the canonical syntax and usage for error handling in JavaScript.

Reference: "The try...catch statement consists of a try block, which contains one or more statements, and a catch block, containing statements that specify what to do if an exception is thrown in the try block."

Source: MDN Web Docs, try...catch Statement, Statements & declarations section. (developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch)

2. Microsoft Docs: Client scripting examples for model-driven apps consistently use the standard JavaScript try...catch syntax for synchronous error handling and promise-based .catch(function (error) { ... }) for asynchronous operations.

Reference: "Use try/catch blocks to make sure your code will not fail on unexpected errors."

Source: Microsoft Docs, Apply business logic using client scripting in model-driven apps, Best practices section. (docs.microsoft.com/en-us/power-apps/developer/model-driven-apps/client-scripting-best-practices)

Business process flows in Dynamics 365 Sales support three automatic triggers—Stage Entry, Stage Exit, and Process Completed. Only a classic Dynamics 365 workflow can be associated with the Process Completed trigger. Creating a workflow that sends an email and assigning it to the Process Completed event guarantees the sales manager is notified the moment the flow is finished, without any manual action from users.

B. Action step – merely tells a user to perform an action; it cannot execute automation or run on completion.

C. Data step – captures data in the form; it has no capability to send notifications.

D. Power Automate flow step – runs on-demand inside the BPF stage and is started by the user, not by the Process Completed trigger.

1. Microsoft Docs, “Add an automated step (workflow) to a business process flow,” Dynamics 365 Customer Engagement developer guide, Section: ‘Process Completed workflows’. https://learn.microsoft.com/power-apps/developer/model-driven-apps/add-workflow-process#process-completed (accessed 2023-10-11).

2. Microsoft Docs, “Business process flows overview,” Power Apps Guide, Paragraph ‘Supported triggers for classic workflows’. https://learn.microsoft.com/power-apps/maker/model-driven-apps/create-business-process-flows#supported-triggers (accessed 2023-10-11).

3. Aitken, “Extending Dynamics 365 with Processes,” University of Washington IS School courseware, Module 5, p. 34-35 (describes BPF Process Completed workflow usage).

To add custom controls (like a slider) to a Business Process Flow (BPF), you must use a manual FormXML manipulation process because the BPF designer does not natively support adding custom controls to steps.

First, you configure the desired control on a standard entity form to generate the correct XML definition. Next, you export the solution containing the BPF entity. You then locate the BPF's FormXML and manually copy the <controlDescription> and unique IDs from the entity form's XML into the BPF form's XML. Finally, you re-import the modified solution into Dataverse to apply the changes. This allows the BPF to render the custom control for the data field.

Microsoft Learn (Power Apps Documentation): "Add custom controls to business process flows" — This section details the requirement to manually edit FormXML to use controls like sliders within BPF stages.

Microsoft Learn (Dataverse Developer Guide): "Customize entity forms" — Explains the structure of FormXML and how elements define the behavior of custom controls.

Microsoft Power Platform SDK: "Work with solutions" — Outlines the export, manual modification of customization.xml (FormXML), and re-import process for advanced UI customizations not available in the designer.

Troubleshooting Rendering: Appending &ribbondebug=true to the URL triggers the Command Checker tool in Model-driven apps. This tool is the official method for diagnosing why specific ribbon buttons (like New or Save) are hidden or not rendering correctly by evaluating display and enable rules in real-time.

Customizing the Ribbon: The Ribbon Workbench (authored by Scott Durow) is the industry-standard tool, officially recommended in Microsoft documentation, for modifying the Command Bar. It provides a graphical interface to add custom buttons, such as an "Email" button, without manually editing complex RibbonDiffXml files.

Microsoft Learn (Power Apps): "Troubleshoot ribbon issues in Power Apps" (Section: Command Checker). This document details using &ribbondebug=true for identifying visibility issues.

Microsoft Learn (Dataverse): "Customize the ribbon" (Section: Community tools). It explicitly lists Ribbon Workbench as the recommended tool for editing the ribbon.

Microsoft Docs (Power Platform Developer Guide): "Define ribbon commands" and "Ribbon XML reference." These sections explain the underlying architecture that Ribbon Workbench manages for UI customizations.

Microsoft Power Apps Documentation: "Use Command Checker to troubleshoot ribbon buttons."

Supervisors (Security roles): In Dataverse, Security roles are the primary mechanism for defining a user's access level to specific table types (entities). They define permissions such as Create, Read, Write, and Delete based on ownership or business unit hierarchy.

Salespeople (Field level security): When specific sensitive data within a record (like a social security number or credit limit) must be restricted while the rest of the record remains visible, Field-level security (Column-level security) is the appropriate tool.

Developers (Environment security): To manage who can create resources, apps, or flows within a specific sandbox or production instance, Environment security (assigning roles like Environment Admin or Environment Maker) is used to control access at the container level.

Microsoft Learn (Power Platform Security): "Security roles and privileges" section. Describes how roles define access to data and UI components. (Document ID: wp-security-dataverse)

Microsoft Learn (Power Platform Admin): "Control user access to environments: security groups and licenses." Explains how to restrict developer and user access to specific environments.

Microsoft Learn (Dataverse): "Column-level security to control access." Details how to restrict access to specific columns (fields) within a table.

Microsoft Power Platform Guidance: "Security Architecture" (Whitepaper). Section 3.2: Defining Organizational Security Boundaries.

Entity Relationships: To allow a Bill of Materials (BOM) to include subcomponents, you must define a 1:N (One-to-Many) or N:N (Many-to-Many) relationship. This allows individual BOM records to be associated with multiple subcomponent records within Dataverse.

Entity Auditing: Microsoft Dataverse auditing is specifically designed to track record changes. It logs the date and time of the change and the identity of the user who performed the action. While "Change Tracking" allows external applications to pull incremental data changes, only "Auditing" provides the historical "who and when" reporting required by the scenario.

Microsoft Documentation: Create and edit 1:N (one-to-many) or N:1 (many-to-one) table relationships, Dataverse Table Relationships section.

Microsoft Documentation: Manage Dataverse auditing, "Enable auditing for an environment" and "Enable auditing for a table" sections.

Microsoft Documentation: Use change tracking to synchronize data with external systems (Distinguishing Change Tracking from Auditing).

Microsoft Power Platform Fundamentals (PL-900/PL-200/PL-400): Module: Work with Tables and Data in Dataverse, Section: "Audit and Compliance."