Dataverse auditing has three independent on/off switches — miss any one of them and you get silence when auditors come asking. This lesson walks through every configuration layer: enabling environment and table auditing, setting column-level audit flags, defining retention policies that won't surprise you with storage bills, and surfacing the Audit History subgrid directly on your model-driven app forms.

You've just been pulled into a compliance meeting. Someone changed a contract value from $450,000 to $45,000 three weeks ago, and nobody can explain why. Your organization's auditors want to know who made the change, when, and what the previous value was. If Dataverse auditing was properly configured at the time, you can answer every one of those questions in under two minutes. If it wasn't, you're looking at an uncomfortable conversation and probably a gap in your SOC 2 or ISO 27001 documentation.
Dataverse auditing is one of those platform features that sits quietly in the background — until the day everyone desperately needs it. The good news is that configuring it correctly isn't complicated. But there are enough moving parts — environment-level switches, table-level switches, column-level switches, retention policies, and form-layer display — that it's easy to get one layer right while missing another. This lesson walks through every layer systematically, using a realistic scenario involving a contract and opportunity management system, so you understand not just what to click but why each layer exists and how the layers interact.
By the end of this lesson, you'll have a production-ready audit configuration: environment auditing enabled, specific tables opted in with the right columns tracked, a retention policy that won't silently blow up your storage budget, and an Audit History subgrid surfaced directly on your model-driven app form so users and compliance officers can review change history without leaving the record.
What you'll learn:
This lesson assumes you're comfortable with:
You'll need System Administrator access to a Dataverse environment (not just System Customizer — some audit settings are admin-only).
Before touching any settings, you need to internalize this: Dataverse auditing has three independent on/off switches, and all three must be ON for a column change to generate an audit record. Miss any one of them, and you get silence — no errors, no warnings, just missing data when you need it most.
The three tiers are:
Tier 1: Environment-level audit switch. This is the master switch. If auditing is disabled at the environment level, no audit records are created anywhere in that environment, regardless of what table or column settings say. This setting lives in the Power Platform admin center.
Tier 2: Table-level audit switch. Even with the environment switch on, each table must individually opt in to auditing. Tables ship with auditing disabled by default (with a few Microsoft-owned exceptions like the User table). You enable this per table in the table's properties.
Tier 3: Column-level audit switch. Within an audit-enabled table, each column must also be individually opted in. When you enable auditing on a table, Dataverse does not automatically audit every column — it audits only columns that have their own audit flag set to true. Some standard columns get this by default; custom columns need manual configuration.
This architecture exists for good reason. Logging every change to every column in every table would generate enormous data volumes and significant performance overhead. The three-tier model lets you be surgical: audit the Contract Amount and Status fields on the Contract table, but skip the internal Notes field nobody cares about.
Key insight
The relationship between these tiers is strictly AND logic. Environment=ON AND Table=ON AND Column=ON → audit record created. Any layer set to OFF → no audit record, with no indication that tracking was missed. This is why post-configuration verification matters so much.
Now let's configure each tier correctly.
Navigate to admin.powerplatform.microsoft.com and sign in with your admin credentials.
From the left navigation, select Environments, then click on the environment you're configuring — in our scenario, let's call it "ContractOps - Production."
On the environment detail page, click Settings in the top command bar. This opens the Settings panel. Expand the Audit and logs section, then click Audit settings.
You'll see a panel with these key toggles:
For most compliance scenarios, you want Start Auditing enabled. Whether you enable Log access depends on your requirements — it generates significantly higher log volume since users open records far more frequently than they change them. For a contract management system where you need to prove who viewed sensitive contract terms, it's worth enabling. For general change tracking, leave it off.
Warning
Enabling Log access on high-traffic tables can generate substantial audit log volume, which directly impacts Dataverse storage consumption and costs. If your environment has thousands of daily active users accessing records frequently, model this out before enabling read logging broadly. Enable it selectively by table rather than globally if possible.
After enabling Start Auditing, click Save. The environment audit switch is now on.
You can also check the environment audit status from inside the maker portal. Navigate to make.powerapps.com, select your environment, go to Settings (the gear icon) → Advanced Settings → Settings → Administration → System Settings → Auditing tab. This shows the same switches in the classic UI. It's sometimes useful to check here if you're troubleshooting discrepancies.
With the environment switch on, you can now opt individual tables into auditing. Let's work through enabling auditing on two tables that are central to our contract management scenario: Contract (a custom table) and Opportunity (if you're using Dynamics 365 Sales tables).
Navigate to make.powerapps.com and open your solution. In the solution explorer, find your Contract table and click on it to open its properties.
In the table property panel, scroll down to find the Advanced options section and expand it. You're looking for a property called Audit changes to its data — a simple checkbox. Check it.
Click Save (you're saving the table schema change, not publishing yet).
Repeat this for every table you want to audit. For our scenario:
Tip
If you're working in an unmanaged solution layer, table audit settings follow the solution. When you export a managed solution and import it into another environment, the audit-enabled flag travels with the table definition. This means your compliance configuration is part of your deployment pipeline — which is exactly what you want. See Solutions for Model-Driven Apps: Publishers, Managed vs Unmanaged, and Solution Layering for how this fits into a proper ALM strategy.
Some settings are easier to find in the classic UI, and many veteran makers still prefer it. From the maker portal, go to Solutions, open your solution, click the ... menu on a table, and select Switch to classic. Alternatively, navigate to https://[yourorg].crm.dynamics.com/tools/solution/edit.aspx?id=[solutionid].
In the classic solution explorer, expand Entities (the classic term for tables), click your Contract entity, and look at the General tab. You'll see an Auditing section with a checkbox labeled Enable Auditing. Check it, then click Save.
Both paths achieve the same result — they set the same metadata property on the table definition.
Some out-of-the-box Microsoft tables — like User (systemuser), Team, and Security Role — have auditing enabled by default and cannot be disabled. Others, like Account and Contact, have auditing available but not enabled by default. When you enable auditing on Account, you're opting that table's data changes into the audit log. This is worth doing for master data tables where unexpected changes would have downstream consequences.
This is where most practitioners get tripped up. They enable the environment switch, enable it on the table, then discover three weeks later that the specific column they care about — say, Contract Amount — was never actually tracked because the column-level flag was off.
When you first enable auditing on a table, Dataverse automatically sets the audit flag to true on most standard columns. However, the behavior isn't consistent across all column types:
This last point is critical. If you have an existing table with 40 custom columns and you enable table-level auditing today, go check each column.
In the Power Apps maker portal, open your solution, navigate to the Contract table, and select Columns. Click on the Contract Amount column to open its properties.
In the column editor, expand Advanced options. You'll see a property called Enable auditing with a toggle. Make sure it's set to Yes.
For our contract management scenario, here's the column audit strategy:
| Column | Audit Enabled | Reason |
|---|---|---|
| Contract Amount | ✅ Yes | Financial compliance — changes need full history |
| Contract Status | ✅ Yes | Workflow compliance — status transitions are auditable |
| Contract Owner | ✅ Yes | Ownership changes are significant |
| Effective Date | ✅ Yes | Date changes affect contract validity |
| Internal Notes | ❌ No | High-churn field, not compliance-relevant |
| Last Synced (integration column) | ❌ No | System-managed, changes constantly, audit noise |
| Contract Description | ✅ Yes | Legal text changes are significant |
Note
Audit-disabling a column doesn't delete existing audit records for that column — it just stops generating new ones from that point forward. If you later re-enable it, auditing resumes but there will be a gap in the history.
If you have many columns to configure, the classic solution explorer is faster. Open the entity in classic view, click Fields in the left panel. The fields list has an Auditing column showing Yes/No for each field. You can click into individual fields to toggle the setting.
For programmatic bulk configuration — useful when deploying to multiple environments — you can use the Dataverse API or PowerShell with the Power Platform CLI:
# Using PAC CLI to export, modify, and re-import solution
pac solution export --name ContractOpsSolution --path ./exports --managed false
# Then in the solution XML, find column definitions like this:
# <attribute PhysicalName="new_contractamount">
# <AuditEnabled>1</AuditEnabled> <- 1 = enabled, 0 = disabled
# </attribute>
pac solution import --path ./exports/ContractOpsSolution.zip
This approach works well in a CI/CD pipeline where you're managing audit settings as part of your solution configuration rather than clicking through each environment manually.
This is the section most tutorials skip, and it's the one that causes surprise storage bills and compliance gaps six months into production.
Dataverse audit logs are stored in a dedicated log storage layer (separate from database storage). By default, audit logs are retained for 30 days in environments without a Dynamics 365 app license, and potentially longer with certain licenses. But the actual default varies by environment type and licensing, and Microsoft has been evolving this.
The retention policy determines how long audit records are kept before they're automatically purged. Setting this correctly is a balance between:
Navigate to the Power Platform admin center → Environments → Select your environment → Settings → Audit and logs → Audit retention policy.
You'll see a Retain these logs for dropdown with options including 30 days, 90 days, 180 days, 1 year, 2 years, 3 years, and "Forever."
For our contract management scenario, we'd set this to 7 years to cover SOX retention requirements. If your organization has different requirements, map them here:
| Scenario | Recommended Retention |
|---|---|
| General business operations | 1-2 years |
| Financial services / SOX compliance | 7 years |
| Healthcare / HIPAA | 6 years |
| EU data operations / GDPR | Varies — consult legal |
| Government contracts | Often 7-10 years |
Warning
The "Forever" retention option is tempting but dangerous in production. Audit logs that never expire will grow continuously and can consume your entire Dataverse log storage allocation, causing new audit records to fail silently. Unless you have a specific legal requirement for indefinite retention, choose the longest defined period that meets your compliance needs and implement a data archival strategy for older records.
To check your current audit log storage consumption, go to the Power Platform admin center → Resources → Capacity. The Log tab shows how much log storage you're consuming versus your allocation.
If you're approaching your allocation limit, you have a few options:
For long-term archival beyond what you want to keep in Dataverse, you can export audit logs to external storage. The most common approach is using the Dataverse Web API to query the audits entity and export to a data lake, then set your Dataverse retention to a shorter period. This is a solid cost-management pattern for environments with high audit volume:
GET https://[yourorg].crm.dynamics.com/api/data/v9.2/audits?
$filter=createdon le 2024-01-01T00:00:00Z
&$select=createdon,userid,objecttypecode,action,changedata
&$orderby=createdon asc
&$top=5000
This query returns audit records older than a given date, which you can then export to your archival destination before the Dataverse retention policy purges them. Building a scheduled Power Automate flow to execute this export pattern monthly is a practical approach that doesn't require custom code.
Before moving on to the form configuration, take five minutes to verify end-to-end audit capture. This is the step that saves you from discovering a misconfiguration during an audit.
If the audit is working, you'll see a new audit record for the Contract table showing the field change, the old value, the new value, the user who made the change, and the timestamp.
If you don't see the record, work through the tier checklist:
Tip
Customization changes to table and column audit settings require a Publish All Customizations action before they take effect. This is a commonly missed step. After configuring your audit settings, go to Solutions, open your solution, and click Publish all customizations. Then re-run your verification test.
You can also view audit logs directly from the classic admin interface. Navigate to Settings → Auditing → Audit Log Management in your Dataverse environment. This interface lets you filter audit records by entity, user, date range, and action type. It's useful for spot-checking, but for systematic review, the form-embedded Audit History subgrid (which we're about to configure) is much more practical for end users.
Now that auditing is capturing data, the next challenge is surfacing that data where people actually work — directly on the record form. Without this, users need to navigate to a separate admin interface to see change history, which breaks workflow and means most people never bother.
The Audit History subgrid puts a live, filterable view of that record's audit log directly on its form. When a contract manager opens a Contract record and sees the amount was changed yesterday by a specific user, that context is immediately actionable.
The Audit History subgrid isn't a standard related entity subgrid like you'd use for contract line items. It's a special built-in control that queries the audit entity filtered to the current record's ID. You add it to a form through the form designer, but the available columns and filtering behavior are controlled by the platform, not by a custom view you define.
Note
The Audit History subgrid shows changes only for the current record — not related records. So on a Contract form, it shows changes to that specific contract's fields. To see changes to related Contract Line Items, you'd need to open each line item record individually, or build a custom solution using the Dataverse API.
Open your solution in the Power Apps maker portal, navigate to your Contract table, and select Forms. Open the main form (typically named "Main" or "Contract Main Form").
In the form designer, decide where you want to place the audit history. The best practice is to put it on a dedicated tab — something like "History" or "Audit Trail" — so it doesn't clutter the primary data entry experience. If you need a refresher on adding tabs and sections to forms, that's covered in depth in the form design lesson.
Step 1: Create the Audit History tab
In the form designer's left panel, click Component (the plus icon) → 1-column tab. A new tab appears at the bottom of the form. Click on the tab header and rename it to "Audit History" in the right properties panel. Set the Name property to tab_audit_history.
Step 2: Add a subgrid component
Click inside the tab's section to give it focus, then in the left component panel, expand Grid → Subgrid. Drag the Subgrid component into your tab section.
Step 3: Configure the subgrid for Audit History
The New Subgrid configuration dialog will appear on the right. Here's where it gets specific:
audit entity.Set the display properties:
subgrid_audithistoryTip
Set the Rows per page to 10 or 15. The audit subgrid can accumulate hundreds of records for active contracts, and showing 50 rows by default makes the form feel sluggish. Users who need to dig deep can page through or filter the subgrid.
Step 4: Save and publish the form
Click Save in the top right of the form designer, then Publish. Publishing the form is required — the saved state isn't visible to end users until published.
Open a Contract record that you've previously made changes to (after auditing was configured and verified). Navigate to the "Audit History" tab. You should see a grid with columns including:
If the subgrid is empty despite you having made changes, check:
This is a critical step that most implementations forget. Even if the Audit History subgrid is on the form, users will see an empty grid or an error if their security role doesn't have read access to the audit entity.
Navigate to Settings → Security → Security Roles, open the relevant role (for example, "Contract Manager"), go to the Core Records tab (or search for "Audit" on the Custom Entities tab depending on your environment version), and ensure Read privilege is set to at least Organization level for Audit Summary View and Audit History entities.
For a full walkthrough of configuring security roles and table privileges, see the Configuring Dataverse Table Permissions in Model-Driven Apps lesson.
Warning
Be deliberate about which roles get Audit History read access. Audit logs contain old values of fields — which could include sensitive data like salaries or contract terms. If you have column-level security on certain fields (see Column-Level Security and Record Sharing in Dataverse), be aware that audit logs may still expose old values to users who have Audit History read access but were otherwise restricted from the field. This is a known nuance — audit data bypasses column-level security restrictions.
Let's put everything together in a realistic exercise. You have a Contract table with these custom columns:
new_contractamount (Currency)new_contractstatus (Choice)new_ownerid (Lookup to User)new_effectivedate (Date)new_expirationdate (Date)new_internalnotes (Text, multiline)new_legalentity (Text)Your compliance requirements:
Work through these steps:
Step 1: Enable environment auditing
Step 2: Enable table-level auditing on Contract
Step 3: Configure column-level auditing
| Column | Action |
|---|---|
| new_contractamount | Verify audit flag = Yes |
| new_contractstatus | Verify audit flag = Yes |
| new_ownerid | Verify audit flag = Yes |
| new_effectivedate | Verify audit flag = Yes |
| new_expirationdate | Verify audit flag = Yes |
| new_internalnotes | Set audit flag = No |
| new_legalentity | Verify audit flag = Yes |
Step 4: Set retention policy
Step 5: Publish customizations
Step 6: Verification test
Step 7: Add Audit History subgrid to Contract main form
Step 8: Grant security role access
Step 9: End-to-end user test
Work through the checklist in order:
If you can't find "Audit History" in the subgrid's Table dropdown, your user account may not have sufficient permissions in the maker portal, or you may be looking in the wrong place. Try typing "audit" to filter. If it still doesn't appear, check that your environment is Dataverse-enabled (not a legacy Common Data Service environment) and that you're using a supported form designer version.
This almost always means certain columns have auditing disabled at the column level. Open each column you care about, check the audit flag explicitly, set it to Yes, and publish. Don't assume columns are audited just because the table is.
Audit log storage consumption surprises organizations that enable Log Access on high-traffic tables. Mitigations:
If you see more changes than expected — particularly system-generated updates — check whether any automated processes (flows, plug-ins, integrations) are touching those records. Automation changes are attributed to the user account the automation runs under, so you can identify the source from the Changed By column. See Configuring Dataverse Table Event Plugins and Real-Time Workflows in Model-Driven Apps for how server-side logic generates audit events.
If you have a gap in audit history, the most likely explanations are:
Check the Power Platform admin center's Activity Log (via Microsoft 365 compliance center → Audit) for admin actions that modified audit settings. This is a case where Microsoft 365 audit logs (separate from Dataverse audit logs) provide the meta-audit trail.
Key insight
For compliance-critical environments, consider configuring Dataverse auditing and field-level change history alongside alerts when the environment audit switch changes state. You can build a Power Automate cloud flow triggered on a schedule that checks the organization entity's audit-enabled status and sends an alert if it's unexpectedly disabled.
You've now built a production-ready Dataverse audit configuration from the ground up. Let's consolidate what you've accomplished:
The three-tier model is now clear: Environment → Table → Column, all three must be active, and all three must be published before any audit data flows. Missing one tier fails silently, so the verification test after configuration isn't optional — it's essential.
Retention policy is set intentionally: You chose a retention period based on your compliance requirements, not the platform default. You understand the storage implications of Log Access and "Forever" retention, and you have a strategy for archiving data that needs to be kept longer than you want to store in Dataverse.
The Audit History subgrid is live on your form: Compliance officers and power users can see change history directly on the Contract record without needing admin access or separate tooling. You've configured the right security role access so the right people see the data.
For your next steps, consider:
Auditing is one of those platform capabilities that you configure once and rely on forever — but only if you configure it correctly. What you've built here will answer the question "who changed what and when?" every time it's asked.