CCNA Dataverse Foundations Questions

A rollup column aggregates values from related records in a one-to-many relationship, applying functions such as SUM across child expense rows. It stores the computed total cost on the parent project record, matching the stem's requirement for a derived sum of associated expenses.

A synchronous plug-in on the Pre-Operation stage runs within the database transaction before the Order record is created. It can retrieve the related Account's CreditLimit and compare it to the Order total. If the limit is exceeded, it can throw an InvalidPluginExecutionException to cancel the operation. This ensures validation regardless of the data entry method, as all create operations trigger the plug-in.

System charts are a built-in chart type available in model-driven apps, configured against table data and rendered on dashboards or views. They are defined in the solution and available across the environment, unlike personal charts.

A lookup column creates a many-to-one relationship from the feedback table to the account table. It allows selecting a single account record and stores a reference to that record. This enforces referential integrity and enables navigation to the account from the feedback record. It is the standard way to associate a record with another table in Dataverse.

Tables are solution-aware Dataverse metadata, so they can be packaged, versioned and transported between environments as solution components. Including the table carries its columns, relationships and keys, satisfying the stem's requirement for a component that a Dataverse solution can contain.

A synchronous PreOperation plug-in on Update can compare the incoming received date to the pre-image value and throw InvalidPluginExecutionException if they differ, which cancels the transaction. This enforces immutability for every update path, including the Web API and flows, while leaving the inspection date freely editable. A calculated column can then compute elapsed days from the two dates.

A parental relationship enforces cascade delete, so removing the project record automatically deletes all associated milestone records. This satisfies the stem's requirement that milestones be tied to a project and removed when that project is deleted, unlike a referential relationship with no cascade.

Business Rules evaluate a condition on one column and then hide, show, set or validate fields without code, running client-side and server-side. This directly satisfies the stem's requirement to hide a field based on another field's value across forms.

Developer environments are a distinct Power Platform environment type, provisioned for individual makers to build and test without production licensing constraints. It satisfies the stem's requirement for a creatable environment type, differing from Production, Sandbox, Trial and Default in purpose and lifecycle.

Dataverse is provisioned automatically as the default database when a new environment is created, unless the maker explicitly selects an alternative such as SQL Server or the environment is created without a database. This satisfies the scenario's default database type requirement.

Main forms are the primary full-page interface for creating and editing a table's records in model-driven apps, containing all configured columns, sections and tabs. They satisfy the requirement by serving as one of the two standard form types.

A View defines the filter criteria, columns and scope that determine which records a user sees. It satisfies the requirement by restricting the underlying object's records to those matching the specified criteria, without altering the stored data itself.

Dataverse combines privileges across multiple security roles additively, forming a union, so the granting role's access overrides the restricting role's denial. This satisfies the scenario: the user sees records because no role subtracts privileges from another.

Record-level security in Dataverse is enforced through security roles and access levels. By setting the access level to 'User' or 'Business Unit', you can restrict users to only see records they own or that are shared with them. This directly addresses the requirement to control record visibility based on ownership.

After enabling table auditing, you must also enable auditing on each individual column that you want to track. Dataverse does not audit all columns by default; only those explicitly enabled will have changes recorded. This allows granular control over what is audited.

Parental behavior in a one-to-many relationship means that when the parent record (Table A) is deleted, all child records (Table B) are also deleted. This cascading delete matches the requirement. It also allows for cascading assignment and sharing, but the key here is the cascade delete.

Setting a column as Required or Optional is a configurable property in Dataverse, directly satisfying the stem's demand for configurable column properties. This setting controls whether users must supply a value when creating or updating records, enforcing data integrity at the table level without custom code.

The Business Unit access level restricts a user to records owned by their own business unit and its children, matching the requirement that users see only their unit's records. It is more restrictive than Parent: Child Business Units and Organisation, which grant broader visibility.

App Checker scans a model-driven app's configuration and reports errors and warnings, such as invalid component references or missing dependencies. This satisfies the requirement by giving makers a consolidated diagnostic view before publishing, rather than discovering faults at runtime.

Relationship type defines the cardinality between the two tables, letting you choose one-to-many or many-to-many. This directly satisfies the stem's requirement for a configurable table relationship item, since cardinality is a core property set when defining how records in one table associate with records in another.

Alternate keys in Dataverse enforce uniqueness on one or more columns at the platform level. When an alternate key is defined on the project code column, any attempt to create or update a record with a duplicate code will be rejected server-side, regardless of the client. This meets the requirement for server-side uniqueness enforcement.

Date and Time with Time Zone stores the date, time, and the time zone offset in which it was entered. This is the only Dataverse data type that preserves the original time zone offset. It is ideal for scenarios where the exact moment and the originating time zone matter, such as feedback submission from different regions.

A one-to-many relationship from Project to Task correctly models the requirement: one project can have many tasks, and each task is linked to one project. This relationship type creates a lookup column on the Task table pointing to Project, establishing the referential link needed for the cascade behavior.

When you create a custom table in Dataverse, a primary column named 'Name' is created by default. You can rename this column to something more meaningful, such as 'Project Name', and it remains the primary column for the table. This is the standard behavior in Power Apps.

Many-to-Many is a native Dataverse relationship type, allowing each record on either side to relate to multiple records on the other. Dataverse implements it through an intersect entity, so no lookup column is required on either participating table.

The Power Platform admin center is the web portal for managing Dataverse environments, including creating environments, assigning roles, and deploying solutions across them. It provides the centralised administrative interface required to govern environments and solution lifecycle.

This property makes the table and its columns available to the Dataverse search index. Enabling it ensures that records from this table can appear in search results across model-driven apps. It is required for the table to be searchable via the global search experience.

Autonumber columns automatically generate a unique, sequential string when a record is created. The format can include a prefix and a number, producing a human-readable identifier. By default, the column is read-only on forms after creation, so users cannot change it. This meets the requirement for an automatic, unique, and immutable identifier without custom code.

Deleting a managed solution removes its components from the target environment because the solution's publisher owns the lifecycle. Unlike unmanaged solutions, where deletion only removes the solution container and leaves components behind, managed deletion strips the actual artefacts.

The Site Map defines the app's navigation structure, exposing entities as areas, groups and subareas in the navigation bar. It directly satisfies the requirement to move between different entities, since each subarea links to a specific table's views and forms. Without a configured Site Map, users cannot switch entities within the model-driven app.

An Autonumber column automatically generates a unique numeric value for each new record. It can be formatted with prefixes and suffixes, and it is ideal for use as a primary key because it guarantees uniqueness without manual intervention. This meets the requirement for an automatically generated unique identifier.

Dataflows satisfy the bulk-import constraint by extracting, transforming, and loading large volumes directly into Dataverse without code, using Power Query's mashup engine to batch records. Unlike row-by-row API calls, dataflows schedule recurring refreshes and upserts, so high-volume loads complete efficiently and stay synchronised with Microsoft Entra ID-authenticated source systems.

Calculated fields compute values at read time using the platform's calculation engine, supporting arithmetic, concatenation and conditional logic across fields on the same record. This satisfies the requirement for a field type performing mathematical calculations.

The Searchable property allows a column to be included in Dataverse search. When enabled, the column's content is indexed and can be queried using the search API or the global search box. This directly addresses the requirement to quickly find records by searching for a specific text field. It is the correct property to enable.

Business rules enforce field-level requirements at the form and table layer without code, marking columns as Business Required so entries cannot be saved while blank. This satisfies the stem's demand for a primary Dataverse business rule capability, distinct from plugins or JavaScript, which handle validation logic outside the rule engine.

Views are solution components created and edited inside the unmanaged solution layer, so they are classified as Managed when shipped in a managed solution. This satisfies the stem's requirement by being a component type that the platform tracks and packages, unlike unmanaged artefacts.

A custom table in Dataverse provides a centralized, reusable data store. You can define columns, relationships, and business rules. Multiple apps can connect to the same table, and updates to the data are reflected immediately without app changes. This matches the requirement for a shared, easily updatable list.

Security roles define privileges and access levels. Setting the access level to 'User' for an entity means users can only access records they own or that are shared with them. This matches the requirement to restrict users to their own records and not see others' records within the same business unit.

Connection references are solution components that abstract the credentials away from the flow definition. On import into production, the administrator or maker must bind each connection reference to a valid connection owned by an identity in that environment. This is exactly why the developer's personal connections did not travel with the solution and why the flows failed until a mapping was provided.

Custom roles are created by copying an existing role and editing its privileges, letting organisations grant least-privilege access beyond the fixed Microsoft-supplied roles. Dataverse defines exactly two role types: custom and the predefined standard roles. This satisfies the stem's requirement for a genuine security role type, not a permission construct such as teams or business units.

In Dataverse, read and write privileges are configured independently, each with its own access level. A role that grants organization-level read but user-level write allows users to see all records while only editing records they own. This precisely explains why teammates' records are visible but not updatable by others.

Setting the column explicitly when the escalation condition occurs captures the exact moment of escalation and leaves the value intact on later edits. A business rule can do this client-side on status change, while a flow handles server-side or cross-record logic. Either way the value is written by automation rather than the user, satisfying both the timing and immutability requirements.

Setting the Read privilege to Business Unit level allows users to read records that are owned by their business unit. This is the correct configuration to restrict access to records within the user's business unit while still allowing them to see records owned by their team or themselves, depending on other privileges.

The table editor in the Power Apps maker portal is where you create and modify relationships between tables, defining one-to-many and many-to-many associations. This directly satisfies the requirement to define table relationships within the maker portal.

A Choice column with local options allows you to define a fixed list of values specific to that column. Users select one value from the list, ensuring consistency and preventing invalid entries. This matches the requirement for predefined stages with single selection per opportunity.

Auditing records field-level change history, capturing who modified which attribute and when, directly satisfying the requirement to view a record's field change history. Enabling it in the environment's audit settings, plus auditing on the table and columns, produces the visible history.

Business Process Flows render a stage-based guide pinned to the form, walking users through defined stages and steps. This staged guidance delivers the user-friendly process guide on a form that the scenario requires, unlike scripts or business rules.

A Solution wraps customisation components—tables, apps, flows, plug-ins—into a single distributable unit, enabling transport across environments. This packaging and deployment capability is its primary purpose, satisfying the requirement to move customisations between Dataverse environments reliably.

The Default Solution is the unmanaged container holding every component in the environment, including all system tables and customisations. It cannot be exported or deleted, and it exists so all components have a home before being organised into other solutions.

This is correct because a single technician relates to many work orders while each work order holds one technician lookup, which is exactly the one-to-many shape required. Creating the relationship from the technician (one) side automatically provisions the lookup column on the work order (many) side, so no separate column definition or junction table is needed and administrative effort stays minimal.

Parental behavior creates a cascade delete: when the parent (Patient) is deleted, all related child records (Appointments) are also deleted. This matches the requirement that appointments should be removed when a patient is deleted. It also enforces that an appointment cannot exist without a patient.

Solutions only carry components explicitly added to them. If the custom table was created outside the solution or never added, it stays in the default solution and is absent from the exported managed package, so it never reaches production.

A Section control groups related fields into a distinct, collapsible block on a model-driven app form, directly satisfying the readability requirement. Unlike tabs, which organise content across separate pages, sections sit within a tab and provide the visual clustering the stem demands.

A security role bundles table, record and column privileges that determine which Dataverse data a user can create, read, update or delete. Assigning it to a user or team grants those access rights, directly fulfilling the requirement to define data access privileges.

Organization-owned tables have no Owner field, so records cannot be assigned to a user or team. Access is controlled solely through security roles at the organisation, business unit, or user level rather than record ownership.

Autonumber columns in Dataverse automatically generate sequential alphanumeric values when a record is created. By specifying a format like 'PRJ-{00000}', the column will produce values such as PRJ-00001, PRJ-00002, etc. This is the native, supported way to create auto-incrementing identifiers without custom code.

Dataverse allows selected columns to be indexed, and a composite query pattern using an indexed sensor identifier plus an indexed timestamp narrows the result set before row retrieval. This keeps range queries efficient as the table grows, because the platform can seek rather than scan. It is the standard approach for high-volume time-series style tables.

A Dataverse retention policy applies time-based deletion rules to table rows, purging aged records automatically and releasing capacity. This directly addresses the stem's excessive table growth, unlike archiving or auditing changes, which relocate or log data without reducing stored row volume.

Business rules run client-side and server-side to enforce logic without code. Setting the status when ActualDeliveryDate is populated and locking the column when it is empty ensures users cannot manually set Delivered prematurely. This matches the requirement exactly because business rules can both set values and lock columns based on conditions.

The Delete privilege on the table's security role grants the ability to remove records. Removing it revokes that capability entirely, so the user cannot delete the record regardless of other access rights they retain, such as read or write.

The List rows action in the Dataverse connector retrieves multiple records based on a filter expression and can return all matching rows using pagination. It is the standard action for querying a set of records, such as active accounts with a specific industry, and can be configured to return all pages.

Business units define the security boundary within which teams own records; placing Sales and Marketing in separate business units prevents cross-team record visibility when role privileges are otherwise identical. This isolates the Lead records owned by Marketing from Sales users.

A synchronous plug-in registered on the Create and Update messages executes inside the Dataverse pipeline for every write, including model-driven app saves, Power Automate, and the Web API. It can query the related ClassSession records, compare the count to the studio's WeeklyCapacity, and throw an InvalidPluginExecutionException to cancel the transaction. This is the only option that enforces the rule for all data-change paths.

Enabling attachments allows users to attach files directly to records of this table. This is a table-level setting that must be turned on to support file attachments. Without it, the attachment feature is not available for the table.

The Primary Name field on an entity defines which column supplies the display name shown in lookups and views. Setting its property to allow renaming lets users edit that record's name, directly satisfying the question's rename-permission constraint.

Creating a Field Security Profile and assigning it to the user is the required next step. Enabling field security alone does not restrict access; permissions are granted only through profiles. Without a profile assignment, the user retains read access, so this satisfies the stem's constraint that the user must be unable to read the Salary data.

Dataverse plug-ins run synchronously or asynchronously within the platform's event pipeline, ensuring they execute reliably even during bulk imports and background processes. They can perform complex calculations, aggregate data from multiple tables, and update related records. Plug-ins are reusable across apps and provide the most control and reliability for server-side business logic.

An Autonumber column automatically generates a sequential alphanumeric string for each new record, following a specified format such as 'TCK-{00000}'. It ensures uniqueness and readability without custom code, exactly matching the requirement for a consistent, incrementing identifier like 'TCK-00001'.

Date and Time columns are stored in a format Dataverse can filter and sort on the server, enabling efficient range queries over submitted dates. Because existing column types cannot simply be converted in place, the reliable path is to add a properly typed column, populate it from the legacy text values, then repoint views, forms, and reports. This delivers the required query performance.

A synchronous plugin registered on the PreValidation or PreOperation stage executes within the database transaction pipeline before the record is committed, so validation failures block the save. Asynchronous plugins run after commit and cannot prevent persistence.

A rollup column aggregates data from related records and is maintained by the Dataverse platform. It recalculates automatically on a schedule or on-demand, and works regardless of how the related records are changed. This ensures consistency across all data modification channels. Rollup columns are ideal for summing child records like InvoiceLine totals into a parent Invoice TotalAmount.

The Delete privilege controls the ability to remove records. By ensuring the department's security role does not have Delete on the custom table, users can still create and edit but cannot delete. This directly meets the requirement without affecting other operations.

A Multi-select Choice column allows selecting multiple predefined options from a single list. It stores the selections as a comma-separated string and supports filtering using the 'contains' operator. This matches the requirement to store multiple features per listing and filter by a specific feature.

A many-to-many relationship uses an intersect table to link records in both directions, so each contact can relate to several accounts and each account to several contacts. One-to-many would restrict a contact to a single account, failing the scenario.

Client-side business rules execute in the browser, so users can bypass them via developer tools, scripts or direct API calls. Because enforcement happens only in the form's JavaScript layer, it satisfies the stem's constraint that the mandatory requirement is not server-enforced, making circumvention possible.