CCNA Power Apps Capabilities Questions

The app-from-data wizard generates a working canvas app directly from a SharePoint list's schema, auto-creating browse, detail and edit screens without hand-written formulas. This satisfies the no-complex-formulas constraint, letting the analyst track team tasks immediately.

Dataverse enforces role-based access at the environment and table level, so a user lacking a security role with read privilege on the relevant tables sees no records at all. This directly satisfies the stem's constraint: shared app access alone grants no data visibility, since app sharing and Dataverse security roles are independent permission layers.

SaveData writes a collection to local storage on the device, and LoadData restores it. In an intermittent-network warehouse, the app can capture scans into a collection, call SaveData, and later LoadData and submit when connectivity returns. This is the documented offline pattern for canvas apps and works without a network connection.

Form layout, field selection and control placement for model-driven apps are edited in the Power Apps maker portal, where the form designer exposes the table's fields. Editing records in the app itself changes data, not the form definition.

FetchXML filters records using attribute conditions, so the statecode condition restricts results to active accounts while the createdon condition applies a rolling 30-day window. The attribute element limits returned columns to name, accountid and createdon, satisfying the stem's requirement to identify exactly which account data the query retrieves.

Power Apps includes an Excel connector that can connect to tables in Excel workbooks stored in OneDrive for Business or SharePoint. The app can read data and write back changes, such as adding or updating rows, as long as the data is formatted as a table. This allows business users to leverage existing Excel files as a lightweight data source.

A canvas app suits this scenario because it gives pixel-level control over the mobile interface, letting employees capture receipt photos through the device camera and submit them directly. Power Apps canvas apps connect natively to Microsoft Dataverse or SharePoint for storing the images, satisfying the mobile capture and storage requirements.

Canvas apps allow designers to drag and drop controls to create a custom user interface. They can easily integrate with SharePoint lists and use device capabilities like camera and microphone through controls such as Camera and Audio. This makes canvas apps ideal for building mobile inspection apps quickly without writing code. They are the recommended choice for this scenario.

Dataverse provides a built-in data platform with standard tables, relationships and security, so makers bind controls to data without writing code. It satisfies the no-traditional-code constraint by removing the need to provision or query a separate database manually.

Microsoft Dataverse applies role-based security, assigning users security roles that grant privileges at table, record and column level, including owner-team and organisation scopes. This satisfies the requirement to control which users can read, create, update or delete specific data.

Canvas apps give the maker direct control over each control's properties, so conditional formatting such as highlighting overdue tasks uses formulas on the gallery's colour properties. Model-driven apps render forms from metadata and cannot express this per-record styling requirement.

The chart control in Power Apps can be bound to a data source such as a SharePoint list. It automatically updates when the underlying data changes, making it ideal for displaying a live monthly sales trend without additional components or refresh logic.

A gallery bound to the orders data source renders the list, and its OnSelect property can navigate to a detail screen passing the selected record's context. This single-screen-plus-detail pattern avoids duplicating controls per order, meeting the drill-down requirement efficiently.

Security roles in Microsoft Dataverse define privileges at table and record level, including the Delete permission. Assigning a role without delete rights to the relevant users prevents case deletion while preserving read and update access.

The issue is that the Filter function on the Status column may not be delegable with the SharePoint connector, causing Power Apps to retrieve only the first 100 records. By using a delegable condition and confirming the connector supports delegation for that operation, the app can retrieve all matching items from the 8,000-item list.

The Offline capability lets canvas apps cache data locally on the device so technicians can record equipment issues without connectivity, then sync changes automatically once the network returns. This directly satisfies the stem's offline-and-sync requirement.

Templates supply pre-built screens, controls and formulas, so the manager assembles and configures the app through the visual designer without authoring any code. This satisfies the no-code constraint, unlike pro-developer or blank approaches requiring manual formula or component construction.

A canvas app gives the field technicians a fully customised mobile interface, satisfying the requirement for a purpose-built logging experience. It connects directly to the existing SQL database through a native connector, so service calls are read and written without duplicating data or rebuilding the schema.

The Filter function evaluates each record in array1 against the predicate Status = "Active", returning only matching rows. This satisfies the stem's requirement to identify the expression's behaviour: a row-level filter on the Status column, excluding records with any other status value.

Canvas apps can be configured for offline use, which caches data locally on the device and synchronizes changes when the device reconnects. This allows the technician to record inspection results in areas without connectivity and have those records uploaded later. It directly addresses the need for continued operation without an active internet connection.

The on-premises data gateway acts as a bridge between Power Apps and on-premises data sources like SQL Server. It allows secure data transfer without exposing the database to the internet. Installing and configuring the gateway is required for canvas apps to access on-premises SQL Server data.

Power Apps portals provide an external-facing web interface with anonymous or authenticated access, letting partners submit support tickets without a Microsoft Entra ID licence. Submissions write directly to Dataverse tables, satisfying the external-access and Dataverse storage constraints that model-driven or canvas apps, which require internal licensing, cannot meet.

A stale or broken SharePoint connection is the most common cause of intermittent save failures with generic errors. Verifying the connector's authentication and permissions directly addresses the data-write failure described in the stem before investigating formulas or app logic.

Field-level security in Microsoft Dataverse restricts individual column access by user or team, satisfying the requirement that only Premium Support agents view 'SLA Level'. Column permissions are granted through field security profiles, which override table-level privileges, so other roles retain access to the record yet cannot read or update that specific field.

Routing rule sets evaluate case attributes, such as category, against conditions you define and then route the case to a specified queue automatically. This directly satisfies the requirement to assign cases by category without manual intervention, unlike workflows or business rules, which cannot move records between queues.

Canvas apps support offline data access when the data source is Dataverse, and Power Apps Mobile automatically caches records and syncs changes when connectivity returns. This directly satisfies the need to capture GPS, photos, and signatures in remote areas without internet, then synchronize data later.

Optimizing queries to retrieve only necessary data reduces the amount of data transferred over the network, which directly improves performance for remote users who may have slower connections. This is a best practice for canvas apps connected to SQL Server.

Forms are a core component of model-driven apps, rendering the data model for user interaction. They satisfy the stem's requirement by binding directly to Microsoft Dataverse tables, defining how records are displayed and edited. Alongside views and charts, forms constitute the standard interface building blocks generated from the underlying data structure.

The 'Start with data' option in Power Apps allows users to connect to a data source, such as a SharePoint list, and automatically generates a three-screen app with a gallery, detail screen, and edit screen. This requires no coding and provides a fully functional app that can be further customized. It is the fastest way to create a basic app for viewing and filtering data.

Canvas apps are built by writing Power Fx formulas directly on controls, so imperative expressions such as If, Switch and Filter drive behaviour. Model-driven apps instead rely on declarative metadata, business rules and JavaScript, so this formula authoring surface is unavailable there.

AI Builder provides prebuilt models, including invoice processing, that extract structured fields such as vendor, total and date from uploaded documents. It integrates directly into Power Apps, satisfying the requirement for automatic invoice data extraction without custom machine-learning code.

The Camera control captures photos directly on the technician's device, and Microsoft Dataverse stores the image as a file column linked to the service record. This satisfies the requirement to persist photos alongside structured service data in one transactional store.

The Filter function evaluates each record against the condition Stock < 10, returning only matching products to the gallery's Items property. This is the standard Power Fx approach for restricting displayed rows in a canvas app gallery based on a numeric column value.

Dataverse stores DateTime values in UTC, and Power Apps converts them to the signed-in user's local time zone for display and back to UTC on save. Storing UTC and relying on this automatic conversion satisfies the requirement to show each global sales user their own local time.

dependsOn establishes deployment ordering in ARM, so the Office 365 Outlook connection resource is created before the app that references it. Without it, the app could deploy against a connection that does not yet exist.

AI Builder's prebuilt invoice processing model extracts invoice number, date and total from uploaded documents using a trained document-understanding model, returning structured fields the app can bind directly. It satisfies the requirement for automatic field population without custom model training or OCR pipeline building.

The Pen input control is designed specifically for capturing freehand drawing or signatures on touch-enabled devices. It stores the drawing as an image that can be saved to a data source, such as a work order record in Dataverse or SharePoint. This directly meets the requirement of capturing a customer signature and attaching it to a work order.

Editable subgrids let users modify fields inline, satisfying the requirement to edit opportunities without opening records. Switching the subgrid type from read-only Standard to Editable enables this directly within the model-driven app form, avoiding extra navigation. No additional configuration beyond the subgrid control's type setting is needed.

The Switch function evaluates the Priority value and returns the matching colour in one expression, avoiding nested If statements. Applied to the badge's Fill property, it maps Low, Medium, High and Critical directly to colours.

On-premises data gateway connections have their own user list separate from the gateway itself. If finance users are not added as users of the specific connection, their apps cannot use it, producing a data source unreachable error. IT users were likely added, explaining why only they succeed.

When a query cannot be delegated, Power Apps processes only a limited set of records locally, which can cause missing results and ignored filters. SharePoint supports delegation for certain functions and operators, so rewriting filters to use those delegable constructs allows the data source to perform the filtering and return the complete, accurate result set for the gallery.

Configuring Microsoft Entra ID B2B guest access lets external partners authenticate with their own organisational credentials, satisfying the stem's requirement that partners log in using existing Azure AD identities. Guest accounts are invited into the tenant, and Power Apps honours that external identity, avoiding separate local accounts or credential duplication.

Model-driven apps include business process flows natively, guiding users through defined stages and enforcing consistent data entry across the organisation. Canvas apps require this logic to be built manually, so the built-in capability is a genuine advantage where structured, repeatable processes matter.

Security roles in model-driven apps control record-level access through the owner-based privilege model, so assigning roles that grant User-level read on leads restricts each sales rep to records they own. This satisfies the requirement that reps see only their assigned leads, without custom filtering logic.

The Filter function can use a lookup column to retrieve related records from another table. In this scenario, the orders table has a lookup to the customers table, so Filter(Orders, Customer.CustomerId = ThisItem.CustomerId) returns the related orders. This is the standard way to display related data in a canvas app gallery without writing server-side code.

Model-driven apps are generated from the data model defined in Dataverse, including tables, relationships, and forms. They automatically provide a responsive, consistent user interface across devices with minimal manual design. This matches the requirement for an app that is automatically generated and mobile-friendly.

Marking fields as required on the business process flow stage enforces data entry at stage level, blocking progression until those columns are populated. This directly satisfies the stem's constraint: users currently advance stages without completing required fields. Required-stage columns apply validation to the flow itself, unlike form-level requirements, which only govern the form.

AI Builder supplies prebuilt and custom machine-learning models that Power Apps can invoke through components, letting makers add prediction, form processing, or object detection without writing model code. This is a genuine Power Apps capability.

Delegable queries translate filter operations into the data source's own query language, so SharePoint performs the filtering and returns only relevant rows. This avoids downloading the whole list, which is what causes the slow loads and timeouts.

App.Formulas allows named formulas that define values and logic once and reference them throughout the app. They recalculate as needed and can be used on any screen. This provides a single place to maintain shared logic, which supports reuse across multiple screens as the maker requires.

The maker portal's Share command grants named users or security groups permission to run the app, with optional co-owner rights. This is the standard in-tenant distribution mechanism, satisfying the requirement for a valid way to share a canvas app within the organisation.

Offline capability requires the app to store data on the device, since the stem's constraint is no internet in remote areas. Enabling offline use with local caching lets technicians load and submit records without connectivity, syncing to the data source once the device reconnects.

SharePoint lists expose structured data through the SharePoint connector, which canvas apps consume natively via Power Fx formulas such as Filter and Patch. This satisfies the stem's requirement for a usable data source, letting makers read and write list items directly without custom code or an intermediate integration layer.

Business process flows give model-driven apps stage-based, guided navigation that enforces a consistent sequence of steps across the app. This directly satisfies the stem's requirement for a capability that guides users through defined stages, which canvas apps lack natively.

A canvas app from a template provides pre-built screens and controls that the analyst can configure through drag-and-drop, satisfying the no-code requirement. Templates for request tracking already include forms and galleries, so the analyst customises rather than builds from scratch. This suits a simple vacation-request app without writing formulas or code.

SharePoint's connector delegates only certain filter operations on indexed columns, so the query executes server-side and returns just matching rows rather than the full 10,000 items. This directly addresses the slow loading caused by pulling the entire list into the app.

Delegable queries push filtering to the data source rather than pulling entire tables to the client, so the canvas app retrieves only matching records. With over 50 data sources, this sharply cuts the volume transferred and processed locally, directly addressing the slow loading caused by non-delegable operations.

OAuth 2.0 is the only custom connector authentication type supporting the client credentials grant, where the app authenticates as itself using a client ID and secret rather than a signed-in user. This satisfies the API's machine-to-machine requirement.

Model-driven apps are built on Dataverse and require at least one table to store and relate data. Tables define the schema, relationships, and business logic that the app's forms, views, and dashboards surface. Without Dataverse tables, a model-driven app cannot be created or run.

Correct. SharePoint lists are easy to set up, require minimal administration, and are often included with Microsoft 365 subscriptions. Canvas apps are low-code and easy to maintain, making this combination ideal for the business's constraints.

Canvas apps render a fully customisable interface and, with offline capability enabled, cache data locally so technicians can view work orders and capture photos without connectivity, syncing once the network returns. This directly satisfies the stem's offline requirement, which model-driven apps cannot meet.

The Navigate function can pass context variables to the target screen. By specifying a record in the third argument, you create a variable (SelectedCustomer) that holds the selected item. The detail screen can then reference SelectedCustomer to display the record's fields. This is the standard way to pass data between screens in canvas apps.

Dataverse enforces relationships between tables, including one-to-many and many-to-many with cascading behaviour and lookup columns, which satisfies the stem's requirement for rich relationships as a benefit over flat sources such as SharePoint lists or Excel.

Microsoft Entra ID authenticates the canvas app user, and Dataverse is a first-party connector, so the app reaches it through the Power Platform service directly. No on-premises data gateway is required, satisfying the without-a-gateway constraint.

Power Apps apps can be published to Microsoft Teams as tabs or personal apps, letting users run canvas apps directly within Teams channels and chats. This satisfies the embedding requirement without leaving the Teams interface.

Views are saved queries defining which records and columns appear in a model-driven app's grid, and they are core metadata components alongside tables, forms, charts and dashboards. They shape the app's list presentation, satisfying the component requirement in the stem.

The Image column type stores image data natively in Dataverse and renders it in canvas and model-driven forms, satisfying the requirement to persist an uploaded image. File columns hold any binary content but do not display inline, and text columns cannot store the binary payload.

Views define the columns, filtering, and sorting applied to lists of records in a model-driven app. Configuring the Case table view determines which columns agents see in the case list, so it addresses the requirement to define the columns shown in the list. Views and forms are complementary configuration elements for model-driven apps.

A Power Automate flow triggered by 'When a record is updated' fires server-side on the Dataverse table, and a condition comparing the prior and new status values detects the transition to 'Resolved'. This satisfies the automatic email requirement without user interaction.

A subgrid can bind to a saved view, and that view's filter criteria control which records appear. Filtering on the opportunity status field to 'Open' satisfies the requirement that only open opportunities display, without extra code or JavaScript. The subgrid then renders exactly the filtered dataset on the account form.

Power Pages is designed to create external-facing websites that surface Dataverse data to users outside the organization. It supports authentication with external identities, branding, and table permissions that control which records each partner can access. This directly matches the requirement for a secure, branded partner portal backed by Dataverse.

Filter with User().Email satisfies the requirement to filter SharePoint records by the signed-in user's email. User() returns the current user's profile, including Email, resolved at runtime from the authenticated session — here Microsoft Entra ID credentials — so the gallery's Items property returns only rows matching that address.

A business rule runs client-side on the form, evaluating the Amount column and conditionally showing or hiding the Approved field when Amount exceeds 1000. This delivers the conditional visibility requirement without custom code or JavaScript.

PCF controls bind to explicit property types declared in the manifest. A dataset property supplies a collection of records; a text property supplies a single string. With only a text property defined, the control receives no records to render, so the gallery stays empty despite loading successfully.