PL-100: Microsoft Power Platform App Maker Exam Questions's

Building custom business applications with low-code.

Canvas apps and model-driven apps.

Microsoft’s secure, scalable data platform for Power Platform and Dynamics 365.

A service to create automated workflows between apps and services.

The low-code formula language for Power Apps and Dataverse.

A prebuilt integration to external services/APIs used by apps and flows.

Connectors that require additional licensing (e.g., SQL, Salesforce).

An app where makers design UI freely by placing controls on screens.

An app generated from Dataverse data model and processes with standard UI.

A package for transporting apps, flows, tables, and customizations.

A container for solutions, apps, data, and resources with separate governance.

An event that starts a cloud flow (e.g., record created, HTTP request).

A step executed after a trigger (e.g., create record, send email).

Creates or updates a record in a data source.

Returns a subset of records matching a condition.

Pushing data operations to the data source instead of local processing.

In-memory table stored during the app session.

Control that shows a list of records from a data source.

Control bound to a record for viewing or editing fields.

A guided stage-based process on Dataverse records.

A set of privileges defining what a user can do with tables and data.

A saved query defining columns, sorting, and filters for a table.

The layout used to view and edit a record’s fields.

A schema object that stores rows (records) and columns (fields).

A column with predefined selectable values.

A reference to a record in another table.

Metadata that identifies the owner of solution components.

A locked package for distribution where components aren’t directly editable.

A package for development where components can be edited.

Creating and managing apps, flows, tables, and solutions.

Tracking changes to records for compliance and diagnostics.

Restricting access to specific sensitive columns.

An external website built on Power Platform to expose data securely.

Tool to build chatbots without code.

Prebuilt and custom AI models integrated into apps and flows.

A Power Query–based ETL process to load data into Dataverse or other storage.

Solution-aware abstraction for connector authentication per environment.

A solution component to store configurable values per environment.

Full-text, relevance-based search across tables.

Defines navigation (areas, groups, subareas) for the app.

Log of executions with success/failure details.

A flow pattern that routes requests for approval.

Detects formula errors, accessibility issues, and delegation warnings.

Instant runs on demand; automated runs when a trigger event occurs.

A flow that runs at specified intervals.

No-code logic enforced at table level for validation/actions.

Role defining a portal user’s permissions.

A reusable set of canvas components across apps.

Real-time diagnostics for performance and network calls.

Templates to govern, monitor, and nurture Power Platform adoption.

Web API/SDK to programmatically access Dataverse data and metadata.

Governance features like sharing controls and capacity insights.

Testing, training, and development without impacting production.

Configurable period logs are kept before purge.

A unique non-GUID key to enforce uniqueness and improve upserts.

Rules to flag or prevent duplicate records.

How multiple solutions override components by layer order.

User-defined connector to call external APIs with OpenAPI/Swagger.

Rules that control portal users’ table data access.

Allocated database, file, and log storage for the tenant.

Apps built in Teams using Dataverse for Teams with limits.

Robotic automation of Windows apps and legacy systems.

Attended needs user presence; unattended runs without users.

Tool to discover and analyze processes for automation opportunities.

A flow created inside a solution for ALM and deployment.

Application Lifecycle Management from dev to prod with versioning and deployment.

Calling REST APIs directly from a flow.

Pre-filter triggering to avoid unnecessary flow runs.

Retrieving additional pages of results for large datasets.

Limits parallel runs to avoid conflicts or throttling.

Automatic retries for transient connector failures.

Tabular Data Stream endpoint for read-only SQL access to Dataverse tables.

Dataverse table mapping external data without storing it.

Lookup is 1:N or N:1; many-to-many uses an intersect table.

Consistent, versioned deployments across environments.

Toolbar where standard and custom commands appear.

Add/enable commands using Power Fx without JS.

Delegate queries, reduce controls, cache reference data, and minimize OnVisible/OnStart work.

Refactor filters to delegable functions or pre-filter at source; avoid loading entire datasets.

Use SaveData/LoadData with local collections and handle sync logic on reconnect.

Use field-level security profiles and sensitivity labels where applicable.

Assign security roles to users/teams and configure table privileges accordingly.

Create in a solution, use proper data types, and consider impact on forms, views, and integrations.

Create variables in solutions and reference them in apps/flows for environment-specific values.

Add connection references and bind flows/apps to them for environment-agnostic deployments.

Build a component, expose input/output properties, and store it in a component library.

Check run history, inputs/outputs, scope results, and enable concurrency/retry settings.

Create a solution-aware instant flow and call it from a parent flow with 'Run a child flow'.

Use scopes with Configure run after, set variables for error states, and send notifications.

Use trigger conditions or change detection columns to ignore updates from the flow itself.

Use OData $filter, select only needed columns ($select), and enable pagination.

Use parallel branches or timeout with reassign action after a set duration.

Use containers, relative layout properties, and formula-driven widths/heights.

Bind properties (e.g., Color, Visible) to expressions evaluating data state.

Embed a Power BI tile/report using the Power BI control and configure access.

Design stages/steps, add data steps, and set required fields to enforce progression.

Create calculated/rollup columns in Dataverse and let the platform maintain values.

Package in a solution and import into the target; update environment variables and connections.

Export solutions, store source in repo (unpacked with PAC), and use pipelines for CI/CD.

Group connectors into business/non-business and allow needed combinations; exclude dev environments as needed.

Use environment maker role and Managed Environments sharing controls.

Use CoE dashboards, audit logs, and usage analytics in admin center.

Use proper data types, alternate keys, relationships, and avoid excessive columns.

Choose user/team-owned tables when record-level security is required; org-owned for reference data.

Configure relationship behaviors (parental, referential, custom) to control cascades.

Use custom connectors with OAuth, define policies, and store secrets in environment variables.

Train a model, then call the 'Process and save information from forms' action and parse outputs.

Train a prediction model on historical data and call it from flows or apps to score records.

Add conditions to move users down different stages based on field values.

Create web roles, table permissions, and add web page access control rules.

Load small lookup tables on app start into collections and reuse locally.

Use sufficient contrast, keyboard navigation, labels, and test with App Checker.

Batch operations, add delays, use concurrency control, and reduce chattiness to APIs.

Enable pagination and loop with 'List rows' until nextLink is empty.

Use attachment control bound to Dataverse or SharePoint and manage file size limits.

Use Dataverse search or build delegable filter using Contains/StartsWith on indexed columns.

Configure authentication (AAD/B2C), web roles, table permissions, and page access rules.

Export/import as solutions; use deployment profiles and environment variables.

Use choice for finite static options; lookup for relational references across tables.

Simplify expressions, use variables, and avoid heavy processing in repeated controls.

Define scope, set conditions, and actions like show error, set value, or lock field.

Use the modern app designer to add command bar buttons and define actions with Power Fx.

Store UTC in Dataverse and convert in apps using TimeZoneOffset/DateAdd for display.

Use Teams adaptive cards for approval actions and collect responses.

Remove export controls, apply security roles, and use DLP to block connector combinations.

Use Power Platform pipelines or Azure DevOps/GitHub Actions with solution export/import.

Send custom logs to Application Insights or Dataverse for monitoring.

Use SharePoint or Dataverse file columns depending on governance and size needs.

Enable retry policy on connectors or add Do until with delays.

Enable change tracking and use it to sync or trigger downstream processes.

Define alternate key columns and use 'Upsert' actions or Patch with key values.

Configure file size limits, use storage providers, and chunk uploads if needed.

Create layered solutions per domain, shared libraries, and avoid mixing unmanaged edits.

Enforce sharing review, solution checker, and usage insights before promotion.

Store secrets in environment variables; use OAuth where possible.

Use Bootstrap grid, liquid, and web templates with CSS for breakpoints.

Use table permissions and Web API with proper auth; disable anonymous web API if not needed.

Use list components bound to table views with filters and permissions.

Use Process Advisor recordings and analytics to find bottlenecks first.

Owner teams assign ownership; access teams grant access without changing ownership.

Organize users/teams under business units to scope security roles and data access.

Use versioning, maintain backward compatibility, and test in sandbox first.

Use Power Platform admin center backup/restore features and retention policies.

Run static analysis to detect issues and apply recommended fixes.

Cases, Contacts, Accounts; activities; 1:N from Account/Contact to Case; queues and SLAs.

Use galleries/forms with nested data, patch child tables in batches, and leverage concurrent() to parallelize updates.

Use BPF stages tied to different tables, define conditional branches, and synchronize data using flows/plugins.

Use bulk operations, alternate keys, partition workloads, and respect service protection limits with backoff.

Use virtual tables for near-real-time, read-heavy scenarios; move data when offline, performance, or security demands it.