# SFDC Police > A free Chrome extension for Salesforce admins and developers: permissions and record access, data migration and test data, SOQL, metadata, automation (flows, triggers, batch Apex) and, from version 1.1.13, Consumer Goods Cloud troubleshooting, all inside the browser using your existing Salesforce session. 35 modules; free; no separate account or login (it uses the Salesforce session you are already signed in with). Current version on the Chrome Web Store: 1.1.13. Install: https://chromewebstore.google.com/detail/pjpcgahadclnombmadpnhpkhlabccdno Index of these pages: https://www.sfdcpolice.com/llms.txt ## How to export field-level security to Excel in Salesforce Source: https://www.sfdcpolice.com/docs/answers/export-field-level-security-to-excel > Query FieldPermissions and ObjectPermissions and export them with Data Loader, or use SFDC Police to download one Excel grid for many profiles. Salesforce stores field-level security as FieldPermissions records and object access as ObjectPermissions records, one set per profile or permission set, so you can query them and export the results to CSV with Data Loader. You then join and pivot the files in Excel yourself. SFDC Police reads the same records for the profiles, permission sets and permission set groups you pick, and downloads one Excel workbook with a column for each of them and a row for each object, field and tab. ### Without an extension Every profile has a permission set behind it that stores the profile's object and field permissions, and you can query it ([PermissionSet reference](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-permissionset.html)). To query FieldPermissions and ObjectPermissions you need the View Setup and Configuration permission. 1. In Data Loader, click **Export**, choose the PermissionSet object and use this query ([Data Loader export steps](https://developer.salesforce.com/docs/platform/data-loader-impl/guide/exporting-data.html)): `SELECT Id, Name, Label, IsOwnedByProfile, Profile.Name FROM PermissionSet` Rows where IsOwnedByProfile is true belong to a profile, and Profile.Name tells you which one. 2. Note the Ids of the profiles and permission sets you want to compare. 3. Export FieldPermissions for those Ids: `SELECT ParentId, SobjectType, Field, PermissionsRead, PermissionsEdit FROM FieldPermissions WHERE ParentId IN ('0PS...', '0PS...')` Salesforce says to include both SobjectType and Field in the SELECT ([FieldPermissions reference](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-fieldpermissions.html)). 4. Export ObjectPermissions the same way, with PermissionsCreate, PermissionsRead, PermissionsEdit, PermissionsDelete, PermissionsViewAllRecords and PermissionsModifyAllRecords ([ObjectPermissions reference](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-objectpermissions.html)). 5. Open the CSV files in Excel, match ParentId to the names from step 1, and pivot to one column per profile or permission set. Why ParentId and not Parent.Name: the Data Loader guide says Data Loader doesn't support queries that use polymorphic relationships, and the Parent field on FieldPermissions and ObjectPermissions is polymorphic. What to watch for: - **No row means no access.** A FieldPermissions record must have PermissionsRead set to true, or Salesforce deletes it. A field with no access for a profile has no row at all, so it is missing from your export rather than shown as "false". - **Some fields never have rows.** Id, CreatedById, CreatedDate, IsDeleted, LastModifiedById, LastModifiedDate and SystemModStamp are always readable; OwnerId, master-detail fields and universally required custom fields are always readable and editable. - **View All Fields changes the answer.** If a permission set has View All Fields on an object, PermissionsRead is true for every field of that object. - **Modify All Data.** Object permissions that come from Modify All Data have a record Id starting with "000" and can't be updated. ### With SFDC Police In version 1.1.13 the module is called **Data Dictionary**; later versions rename it Permission Matrix. 1. Open SFDC Police in a full tab and choose **Data Dictionary** in the menu. 2. Tick what you want to compare in the **Permission Sets**, **Profiles** and **Permission Set Groups** lists. A permission set group is expanded into the permission sets it contains, and each gets its own column. 3. Click **Generate**. SFDC Police queries ObjectPermissions, FieldPermissions and tab settings for your selection and reads every page of results. 4. Click **Download Excel**. The file is named `DataDictionary_` plus the date. The workbook has up to three sheets. A sheet with no rows is left out. | Sheet | Columns | |---|---| | Object Permissions | Object Name, Object API, then one column per profile or permission set. Cells hold `C R E D VA MA VAF` letters (Create, Read, Edit, Delete, View All, Modify All, View All Fields). | | Field Permissions | Object Name, Object API, Field Name, Field API, Data Type, Field Type, Picklist Values, Required, then one column per profile or permission set. Cells hold `R` or `RE`. | | Tab Visibility | Tab Name, then one column per profile or permission set. | Column headers read `Profile:` or `PS:`. The download holds every row, not only the rows your search box shows. Limits in 1.1.13: - The data comes from the same records as the native method, so a blank cell means that column has no permission row, and a field appears only if at least one selected column has a row for it. - The name columns repeat the API names. Data Type, Picklist Values and Required are present but empty. Field Type is Standard, Custom or Managed, worked out from the API name. - The **Muting Permission Sets** list is there, but in 1.1.13 a muting permission set adds no permissions to the results. Don't use the file to check muting. - If tab settings can't be read in your org, the file has no Tab Visibility sheet. ### Editing permissions from the file You can change `R`/`RE` or object letters in the file and upload it in [Apply Changes](https://www.sfdcpolice.com/docs/features/apply-changes) (from the release after 1.1.13: Permission Matrix → **Import from Excel**). It reads the Object Permissions and Field Permissions sheets, compares them with your org and lists the differences. Click **Deploy N Changes**, then **Deploy Changes** in the confirm dialog. If any profile changes, you must type `DEPLOY` first; for permission set changes only, there is no typing step. In 1.1.13, Apply Changes only updates permission rows that already exist. Blank cells are skipped, so it can't grant access to a field that has none, and emptying a cell doesn't remove access. For those changes, use **Edit Mode** in Data Dictionary, then **Push to Salesforce**. ### Related - [Permission Matrix (Data Dictionary)](https://www.sfdcpolice.com/docs/features/data-dictionary) - [Import from Excel (Apply Changes)](https://www.sfdcpolice.com/docs/features/apply-changes) - [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor) - [Permission sets vs profiles](https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles) ## How do I find where a field is used in Salesforce? Source: https://www.sfdcpolice.com/docs/answers/find-where-a-field-is-used > In Setup, open the custom field and click Where is this used? SFDC Police lists its references and marks which automations read or write it. For a custom field, open the field in Setup and click **Where is this used?**. Salesforce lists the layouts, formulas, Apex, flows, reports and other places that reference the field, up to 2,000 entries. SFDC Police reads Salesforce's dependency data (the MetadataComponentDependency object) from a field label on a record page, and for flows, triggers and Apex classes it opens the source to show whether each one reads or writes the field. Neither list sees every use, so treat an empty result as "nothing recorded", not as "safe to delete". ### In Salesforce Setup 1. From the object management settings for the field's object, go to **Fields** ([Manage Fields for a Specific Object](https://help.salesforce.com/s/articleView?id=platform.viewing_fields.htm&type=5)). 2. Click the field label. 3. Click **Where is this used?**. To open the settings of a layout, formula or other reference, click its label. You need the View Setup permission. The list can include active validation rules, layouts, formula fields, Visualforce pages, Apex classes and triggers, field sets, flows, lookup filters, Lightning pages and reports (columns and filters) ([Find Where a Field Is Used](https://help.salesforce.com/s/articleView?id=platform.fields_references.htm&type=5)). The same article lists what the button does not show: - Reports that reach the field through a lookup from another object (for example, an Account custom field in a report on a custom object with Account). - In a subscriber org, references inside an installed managed package. References you create after installing it do appear. - Reports you can't access, such as a report another user saved in a private folder. - Joined reports. - Anything past the first 2,000 references. The article describes the button on a custom field's detail page only. ### With SFDC Police From a record page: 1. Open a record of the object in Lightning Experience. 2. Hover the field's label. The SFDC Police tooltip appears. Click the label to pin it open. 3. Click **Automations**. For a custom field, the tooltip shows **Where this field is used**: how many automations write it, read it or are unclear, and how many other uses there are. The list is grouped into **Automation & code**, **Apex tests** and **Layouts, reports & other**, and names link to the item in Salesforce where a link is available. To tell reads from writes, SFDC Police opens the source of up to 60 flows, triggers and Apex classes per lookup. Anything it did not open, or could not read (for example managed code), is marked **References**, and the tooltip says so. To explore further, open **Metadata > Where Used** in the extension (also under **All tools** in the floating panel). Search part of the field's API name without `__c`, pick the result, and you see **Used by** (what references it) and **Uses** (what it references). Click any item to explore it in turn. This view does not mark reads and writes. What SFDC Police can't see: - Salesforce documents MetadataComponentDependency as a Beta feature. Through the Tooling API it returns no more than 2,000 records per query and does not include reports ([MetadataComponentDependency](https://developer.salesforce.com/docs/platform/api-tooling/references/tooling-objects/tooling-metadatacomponentdependency.html)). For reports, use Setup's **Where is this used?**. - For a standard field, the tooltip does not use this data. It uses a Process Graph scan of the object's automations instead, and offers to run one if none exists. **Where Used** search finds custom fields, Apex classes and triggers only. - If Salesforce returns its 2,000-reference maximum, the tooltip says there may be more. For the "is it still used?" question across a whole object, open **Metadata > Unused Metadata**, choose **Custom Fields**, pick the object and click **Find unused**. It lists the object's custom fields outside any managed package namespace that have no recorded references, with their last-modified date and an **Export CSV** button. It compares against at most 2,000 custom field references for the whole org; when that cap is hit, the page says to treat the results as partial. The page calls these candidates to review, not fields that are safe to delete. ### Before you delete a field - Check both lists: SFDC Police for automations and read/write, Setup's **Where is this used?** for reports. Ask report owners about private-folder and joined reports, which Setup's list leaves out. - Ask the owners of integrations, data loads and managed packages that use the field. - Salesforce won't let you delete a custom field that is referenced elsewhere, for example by a field update or Apex. Deleting needs the Customize Application and View All Data permissions ([Delete a Custom Field](https://help.salesforce.com/s/articleView?id=platform.deleting_fields.htm&type=5)). - Deleting a field deletes its field history data. You can restore the field and its data for 15 days, or until your org permanently deletes it, whichever comes first (same source). - A restored field keeps a `_del` suffix on its developer name, and a restored formula field stays disabled until you edit and save it. A deleted field counts against your custom field limits until it is hard deleted ([Manage Deleted Custom Fields](https://help.salesforce.com/s/articleView?id=platform.fields_managing_deleted_fields.htm&type=5)). ### Related - [Metadata Peek and field hover tooltips](https://www.sfdcpolice.com/docs/features/metadata-peek) - [Process Graph](https://www.sfdcpolice.com/docs/features/org-process-graph) - [Process Graph guide: every automation that runs when a record is saved](https://www.sfdcpolice.com/blog/guide-process-graph) - [Floating panel](https://www.sfdcpolice.com/docs/features/floating-panel) ## Answers Source: https://www.sfdcpolice.com/docs/answers > Short answers to common Salesforce admin questions: what Salesforce Setup offers, what SFDC Police adds, and the steps for each. ### Answers Each page answers one question that Salesforce admins ask often. The first paragraph gives the answer. Then you get the way to do it in Salesforce itself, the way to do it with SFDC Police, and the limits of each. - [How do I find where a field is used in Salesforce?](https://www.sfdcpolice.com/docs/answers/find-where-a-field-is-used) - [How to export field-level security to Excel](https://www.sfdcpolice.com/docs/answers/export-field-level-security-to-excel) - [Which permission set gives a user access?](https://www.sfdcpolice.com/docs/answers/which-permission-set-gives-a-user-access) For record visibility (sharing, roles, ownership), see [Why can this user see this record?](https://www.sfdcpolice.com/blog/why-can-this-user-see-this-record). ## Which permission set gives a user access in Salesforce? Source: https://www.sfdcpolice.com/docs/answers/which-permission-set-gives-a-user-access > In Setup, open the user, click View Summary, then choose Access Granted By on a permission to see the profile, permission sets or groups that grant it. In Setup, open the user, click **View Summary**, find the permission, open its row-level action and click **Access Granted By**. Salesforce then lists the profile, permission sets or permission set groups that grant it. You can get the same answer with SOQL by joining `PermissionSetAssignment` to `ObjectPermissions` or `FieldPermissions`. In SFDC Police, open **Access Editor**, pick the user, and use **Explain Access** to see which permission set, permission set group or profile grants one object, field, record type or page layout permission, or that none does. ### In Salesforce **User Access Summary.** Salesforce documents this in [View a User's Access Summary](https://help.salesforce.com/s/articleView?id=platform.users_access_summary.htm&type=5) and [Troubleshoot Feature Access Issues](https://help.salesforce.com/s/articleView?id=platform.admin_insufficient_privileges_object.htm&type=5): 1. From Setup, in the Quick Find box, enter **Users**, then select **Users**. 2. Select the user and click **View Summary**. You need View Setup and Configuration. 3. Find the permission among the user's object, user and field permissions. 4. Click the permission's row-level action, then click **Access Granted By**. To see everything inside one permission set or permission set group, open it and click **View Summary** ([permission set summaries](https://help.salesforce.com/s/articleView?id=platform.perm_sets_summary_page.htm&type=5)). **SOQL.** The [PermissionSet object reference](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-permissionset.html) explains that every profile has a permission set that stores the profile's permissions, marked `IsOwnedByProfile = true`. So one query covers the profile and the permission sets. Adapted from the reference's example, this query lists what grants Edit on Account to one user: ```sql SELECT PermissionSet.Label, PermissionSet.IsOwnedByProfile, PermissionSet.Profile.Name, PermissionSetGroupId FROM PermissionSetAssignment WHERE AssigneeId = '005XXXXXXXXXXXX' AND PermissionSetId IN ( SELECT ParentId FROM ObjectPermissions WHERE SobjectType = 'Account' AND PermissionsEdit = true) ``` For a field, query `FieldPermissions` instead. Apex class access is stored in `SetupEntityAccess`, not in these objects. **The catches:** - **Profiles appear as permission sets.** For a profile-owned permission set, read `Profile.Name`. Salesforce says the Name and Label of these permission sets can change. - **No row means no access.** Salesforce stores a permission as a record and stores no record when there is no access, so you can't query for "no access" directly. - **Permission set groups.** A group assignment fills [`PermissionSetGroupId`](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-permissionsetassignment.html). The group's members are in [`PermissionSetGroupComponent`](https://developer.salesforce.com/docs/platform/object-reference/references/standard-objects/object-permissionsetgroupcomponent.html), and a member can be a muting permission set. - **Muting.** A [muting permission set](https://help.salesforce.com/s/articleView?id=platform.perm_set_groups_muting.htm&type=5) removes permissions only inside its own group. If the profile, another permission set or another group grants the same permission, the user keeps it. - **Session-based permission sets.** These are [valid only for the session in which they are activated](https://help.salesforce.com/s/articleView?id=platform.perm_sets_session_use.htm&type=5), and `PermissionSet.HasActivationRequired` marks them. An assignment row does not prove the user has the permission right now. - **Who can query.** Only users with View Setup and Configuration, Assign Permission Sets or Manage User can read `PermissionSetAssignment`. ### With SFDC Police 1. In the sidebar, open **Permissions**, then **Access Editor**. 2. Search for the user by name or email and select them. 3. In the **Explain Access** panel, choose a **Permission Type**: **Object Permission**, **Field Permission**, **Record Type** or **Page Layout**. 4. Pick the **Object**, then the **Permission** (Read, Create, Edit, Delete, View All Records or Modify All Records for an object; Read or Edit for a field), or the field or record type. 5. Click **Explain**. The result shows a **GRANTED** or **NOT_GRANTED** badge and a **Top Reason**, such as `Granted via Permission Set "Sales Ops"`. Three tabs show the detail: - **Grant Paths**: each permission set that grants it. A permission set inside a group shows "via" and the group's name. Badges show **PS**, **PSG** or **MUTED**. - **Muted**: muting permission sets that mute this permission in one of the user's groups. - **Overrides**: the profile, if the profile grants it. To find the permission sets inside groups, Explain Access reads the group's members and recognizes muting permission sets by their `0QM` Id prefix. For a field, it counts the grant only when the user also has object Read (and object Edit for field Edit). When that object access is missing, the Top Reason says so. For a page layout, it shows the layout that the user's profile assigns. **Export Evidence** saves the result as a JSON file. To compare two users, open **Permissions**, then **Permission Intelligence**, then **Compare Users** (from the release after 1.1.13: **Explain Access** → **Compare Users**, or **Compare** → **Users**). Pick **User A** and **User B**, and click **Compare**. Leave **Object** blank to compare object permissions across all objects, or pick an object to compare its fields. Each row is marked **Divergent** or **Match**. **Limits.** Explain Access checks one permission at a time. It does not explain user or system permissions (such as API Enabled), Apex class access or custom permissions; use the User Access Summary for those. For object permissions in 1.1.13, it reads object permission records only, and does not list View All Data or Modify All Data as a source. In the release after 1.1.13 they count: View All Data gives Read and View All, Modify All Data gives every object permission except View All Fields, and the answer names the profile or permission set that holds them. Neither overrides field-level security. It does not check whether a session-based permission set is active, so it lists one as a grant path even when it is not activated. ### Record access is a different question Object and field permissions decide what a user can do with a type of record. They do not decide which records the user can see. That is decided by sharing: ownership, roles, sharing rules and similar layers. For that question, read [Why can this user see this record?](https://www.sfdcpolice.com/blog/why-can-this-user-see-this-record) and [The 10 Layers of Record Access](https://www.sfdcpolice.com/docs/guides/record-access-layers). ### Related - [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor) - [Explain Access (Permission Intelligence)](https://www.sfdcpolice.com/docs/features/permission-chain) - [Permission Sets vs Profiles](https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles) - [How to Find Every God-Mode User in Your Org](https://www.sfdcpolice.com/blog/find-god-mode-users) ## FAQ Source: https://www.sfdcpolice.com/docs/faq > Common questions about SFDC Police — pricing, data privacy, installation, supported orgs, and how it connects. Short answers to the questions admins ask most before installing. #### Is it free? Yes. SFDC Police is free to install and use. There are no seat licenses, no per-user fees, and no credit card required. #### Where does my data go? Only to Salesforce. SFDC Police runs in your browser, against your existing Salesforce session. It reads and writes through the Salesforce APIs you already have access to, and it does not send your org's data to us, because there is no SFDC Police server. Data goes from one org to another only when you run a tool that does that, such as Data Migrator. #### Do I need admin approval or a connected app to install it? No. It is a standard Chrome extension. It does not require a connected app, an OAuth client, or an administrator to pre-approve anything. Any user with the API Enabled permission can use it, with exactly the access their own permissions allow, and no more. #### How does it connect without API keys? It reuses your authenticated Salesforce session — the same one your browser already holds after you log in. There are no API keys to manage. From version 1.1.13 the session ID is held only in the browser's session storage, in memory, and cleared when the browser closes; version 1.1.9 keeps it in the extension's local storage on your computer. When your Salesforce session ends, so does the extension's access. #### Which orgs are supported? Production orgs, sandboxes, scratch orgs, and developer orgs. If you can open it in Lightning in your browser and your user has API access, the extension can connect to it. #### Does it work in Lightning and Classic? It is built for Lightning Experience and Setup, which is where modern administration happens. It works across `lightning.force.com` and `my.salesforce.com` domains. Classic is not tested. #### Will it change my org without asking? Reads change nothing, though each one uses API calls from your org's daily allowance. Writes happen only when you start them, and Data Migrator runs and Data Generator inserts show a preview first. Many write operations (migrations, permission assignments, generated data) can be rolled back from before-state snapshots or a rollback ledger. Check the org name before a write: from version 1.1.13 each full-page tab stays on the org it was opened for. #### Does it respect my permissions? Completely. The extension can only do what your Salesforce user can do. It cannot escalate privileges or bypass sharing — it simply makes the access you already have faster to use and easier to understand. #### Does it support managed packages? Yes. It reads managed and namespaced metadata, so packaged objects, fields, and permissions show up alongside your custom configuration rather than being invisible. #### How do I get started? Install the extension, open any Salesforce page, and it connects automatically. See [Installation](https://www.sfdcpolice.com/docs/installation) for the details, then browse the [feature guides](https://www.sfdcpolice.com/features). ## Documentation Source: https://www.sfdcpolice.com/docs/ > Learn how to install, configure, and use SFDC Police to audit permissions, migrate data, and secure your org. ### What is SFDC Police? SFDC Police is a free Chrome extension that gives admins and developers a closer look at permissions, data, security, and automation across your Salesforce org. It runs entirely on your existing Salesforce session—no API keys, no connected apps, no admin approval required. It talks only to your Salesforce orgs; we run no server of our own, and none of your org data is sent to us. The extension surfaces what's already visible to you through the Salesforce UI, but gives you the tools to answer hard questions: *Who can actually access this record? Is my data safe to migrate? What automations are breaking if I delete this field? Which connected apps are excessive?* ### How the Docs Are Organized These docs are divided into three sections: - **[Installation](https://www.sfdcpolice.com/docs/installation)** — Get SFDC Police running. - **Features** — Module-by-module reference for each tool (Data Migrator, Security Insights, Access Editor, and more). - **Guides** — Concept walkthroughs and workflows for common tasks. ### Start Here Pick your next step: - **New to SFDC Police?** Start with [Installation](https://www.sfdcpolice.com/docs/installation) to add the extension to your browser. - **Migrating data across orgs?** See [Data Migrator](https://www.sfdcpolice.com/docs/features/data-migrator) to copy records between orgs, with rollback and drift detection. - **Auditing your org's security posture?** Read [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights) to find overprivileged users and toxic permission combinations. - **Understanding record access?** [The 10 Access Layers](https://www.sfdcpolice.com/docs/guides/record-access-layers) explains the permission model step-by-step. ### Key Principles **Free.** No premium tier, no per-seat licensing, no dark patterns. SFDC Police is free. **Session-based, not token-based.** The extension reads and writes through your existing Salesforce login. The session is sent only to Salesforce. From version 1.1.13 the session ID is held only in the browser's session storage, in memory, and cleared when the browser closes; version 1.1.9 keeps it in the extension's local storage on your computer. **Privacy-first.** Analysis runs in your browser. Nothing is sent to us: your org's metadata, data and access rules travel only between your browser and the Salesforce orgs you work in. **Practical for admins and developers.** Features are built around real workflows—permission assignment, org migration, drift detection, error recovery, automation dependency mapping—not abstract data dumps. Browse the features or jump into a guide. Questions? The docs include troubleshooting links at the bottom of each section. ## Installation Source: https://www.sfdcpolice.com/docs/installation > Install SFDC Police from the Chrome Web Store and connect it to your Salesforce org. ### Install from Chrome Web Store 1. Open [SFDC Police on the Chrome Web Store](https://chromewebstore.google.com/detail/pjpcgahadclnombmadpnhpkhlabccdno) 2. Click **Add to Chrome** and confirm The extension icon will appear in your toolbar. Chrome keeps the extension up to date on its own; to see which version you have, open **chrome://extensions**. ### Connect to Your Org 1. Open a Lightning or Setup page in your org (for example `https://yourorg.lightning.force.com`) 2. The extension auto-detects your existing session 3. Click the extension icon in your toolbar to open the floating panel 4. You're ready No API keys, connected apps, or admin approval required. The extension reads and writes through your existing Salesforce login. ### What You'll See **Floating Panel** — Quick-access overlay accessible from any Salesforce page. Contains status, actions, context tabs, user search, queries, and the Batch Manager. **Full-page App** — Open a module from the floating panel's **Actions** tab (under **All tools**), or click the extension icon on any tab that is not a Salesforce page. The app has every module (Data Migrator, Access Editor, Security Insights, SOQL Builder, Org Process Graph, and more). ### Supported Surfaces The floating panel loads on Lightning Experience and Setup pages on these domains: - `*.lightning.force.com` - `*.my.salesforce.com` - `*.salesforce-setup.com` - `*.cloudforce.com` and `*.salesforce.mil` It is built and tested for Lightning Experience; Classic is not tested. ### Privacy and Security **Session-based only.** The extension uses your existing Salesforce session. We run no server, so nothing is stored server-side. On your computer, from version 1.1.13 the session ID is held only in the browser's session storage, in memory, and cleared when the browser closes; version 1.1.9 keeps it in the extension's local storage. **Nothing is sent to us.** Analysis, caching and metadata exploration happen in your browser. Your org's data and access rules go only between your browser and the Salesforce orgs you work in. ### Troubleshooting #### Extension not detecting my org Check that you're on a Salesforce page on one of the domains above (for example `.lightning.force.com` or `.my.salesforce.com`). Refresh the page and click the icon again. Your user also needs the API Enabled permission. #### Session expired error Log out and back into Salesforce in your browser tab, then refresh the page. The extension will automatically pick up your new session. #### Blank panel or missing tabs Refresh the Salesforce page and click the extension icon again to reopen the floating panel. ## Access Editor Source: https://www.sfdcpolice.com/docs/features/access-editor > Find a user, manage their permission set assignments, see which permission set or profile gives them an access, and edit that permission set or profile tab by tab. Access Editor is a full-page module that starts from a **user**. You search for a user, see their permission sets and groups, find out where an access comes from, and edit the permission set or profile that grants it, without clicking through Salesforce Setup's separate permission screens. *Top screenshot: 1 User search. 2 Login As, Freeze and Reset Password. 3 Unassign a permission set. 4 Assign a permission set. 5 Clone From User.* ### Features #### User Card Search for a user. The user card shows their email, profile and status, with these actions: - **Login as** the user - **Freeze** or unfreeze the user - **Reset password** - **Create user** (a separate button at the top of the page) #### Permission Set Assignments - Assign or remove the user's permission sets and permission set groups - **Clone assignments**: copy another user's permission set assignments to this user. A preview shows which ones are new before anything is assigned. #### Explain Access Pick an object and a permission (or a field, record type or page layout). Explain Access shows which of the user's permission sets or profile gives that access, or that none does. ![Explain Access answering whether Steve Rep can read Account: granted, with the grant path listed](https://www.sfdcpolice.com/docs/shots/access-editor-2.png) *1 Permission type tabs. 2 Object picker. 3 Explain button. 4 The result, granted here. 5 Permission set (PS) that grants it. 6 Edit Mode, to change that permission set.* #### Edit a Permission Set or Profile In Explain Access, switch to **Edit Permission Set** and pick one of the user's permission sets or their profile. You then edit it one tab at a time: - Objects (create, read, edit, delete, view all, modify all) - Fields (read and edit) - Tab visibility - Page layouts (profiles only) - Record types - Apex classes - Visualforce pages - Custom permissions - Apps Click a checkbox to change a permission. Changes stay on screen until you save them: each tab has its own **Save Changes** button, and the summary table has **Save All**. #### Search & Filter On the Objects tab: - Search objects by label or API name - **Hide Restricted** hides objects where Salesforce blocks creating, editing or deleting records #### Bulk Operations The **Bulk Operations** mode assigns or removes one permission set for many users at once, with a progress view. #### Transaction History Changes made from this browser are listed in **Transaction History**. The list is stored in this browser only. **Rollback** can only undo an entry that kept a copy of the values from before the change, and deletions can't be undone. In version 1.1.9, check the values in Salesforce after a rollback: a save of more than 25 records can show as rolled back without anything changing. From version 1.1.13 such an entry is refused instead, with nothing changed. In the release after 1.1.13, an entry of up to 200 records is reversed all or nothing. ### Workflow 1. Search for a user 2. Open **Explain Access** and switch to **Edit Permission Set** 3. Pick a permission set or profile from the dropdown 4. Open a tab, search for the object or field, and change the checkboxes 5. Click **Save Changes** on the tab, or **Save All** in the summary To compare two users' access side by side, use [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain) → Compare Users (called Permission Intelligence in 1.1.13), or, from the release after 1.1.13, [Compare](https://www.sfdcpolice.com/docs/features/ps-comparison) → **Users**. > Note: The extension uses your own Salesforce session. What you can save depends on your Salesforce user's permissions. ## Apex Tests Source: https://www.sfdcpolice.com/docs/features/apex-tests > See Apex code coverage for your org and each class or trigger, and start a run of all local Apex tests and watch its progress and failures. Apex Tests shows the Apex code coverage Salesforce has recorded for your org, class by class, and lets you start a run of the org's local tests and follow it to the end. Open **Develop → Apex Tests** (in the **BUILD & DEBUG** section). ### How to use it 1. Open the page. Coverage loads on its own. Click **Refresh** at the top to load it again. 2. To run tests, click **Run all local tests** in the **Run tests** panel. The run starts right away; there is no confirmation step. 3. Watch the status, the method count and the progress bar. When the run ends, coverage reloads. 4. Use the search box in the coverage table (**Search classes & triggers…**) to find a class, and sort by any column. If a run is already going in the org, for example one started from Setup or from another tab, the page attaches to that run instead of starting a second one. It also attaches to a running test run when you open the page. ### What you see **Coverage numbers.** **Org-wide coverage**, **Classes & triggers**, **Below threshold** (classes and triggers under 75%) and **Lines covered**. **Coverage table.** One row per class or trigger with **Class / Trigger**, **Covered** (lines covered out of total) and **Coverage** (a percentage and a bar). It starts sorted with the lowest coverage first, and you can export it. **Warnings.** **No code coverage recorded yet** appears when Salesforce has no coverage stored, which happens until tests have run. **Below production-deploy threshold** appears when org-wide coverage is under 75%. **Run status.** The run's status from Salesforce (for example Queued, Processing or Completed), methods completed out of methods queued, and the number of failures. After the run, a **Failures** list shows each test that did not pass as `Class.method` with its message. In version 1.1.13 that includes skipped tests (shown as "Test failed"); in the release after 1.1.13 only failed tests and compile failures are listed. If the run sits in the queue for more than 90 seconds, a note explains that Salesforce hasn't started it yet and that you don't need to run it again. If Salesforce refuses to start the run, the page says so; the usual reason is that the org has no Apex test classes. ### What it reads and writes Reads, through Tooling API queries with your current session: - `ApexOrgWideCoverage` for the org-wide percentage, and `ApexCodeCoverageAggregate` for each class and trigger. - `ApexTestRunResult` and `ApexTestResult` to follow a run and collect its results. Writes: **Run all local tests** calls the Tooling API's `runTestsAsynchronous` with the test level `RunLocalTests`. As the panel says, this runs every local (non-managed) test class in the org. Salesforce stores coverage data only after a test run, so a run updates the numbers this page shows. The page does not edit or deploy code. ### Limits - You can only run all local tests. You can't pick single classes or methods here. - The coverage table reads at most 2,000 classes and triggers. If the org-wide percentage can't be read, the page works it out from those rows. - Up to 200 non-passing test results are read per run. - The page checks the run every 3 seconds at first, slowing to every 30 seconds, and pauses while the tab is hidden. After an hour it stops checking to save API calls and shows **Keep watching**. The run itself keeps going in Salesforce, and you can follow it in Setup under Apex Test Execution. - Stack traces of failed tests are read but not shown. ### Related - [Debug Logs](https://www.sfdcpolice.com/docs/features/debug-logs) - [XML Builder](https://www.sfdcpolice.com/docs/features/xml-builder) ## API Dashboard Source: https://www.sfdcpolice.com/docs/features/api-dashboard > See your org's API limits, the Salesforce API calls the extension made with the query or error behind each, and which client apps used the API most. API Dashboard shows how close the org is to its API limits, next to a log of the calls SFDC Police itself made. Open **Develop → API Dashboard**. ### How to use it 1. Open the page. It loads on its own and keeps itself up to date while the tab is open. **Refresh** reads everything now. 2. Under **Org API Limits**, click **Show All N Limits** to see every limit the org reports, with a search box. **Collapse** hides it again. 3. Under **Recent Calls**, type in **Search endpoint, query or error...** to find a call. **Copy** copies a query's SOQL. ### What you see **Summary cards** about the extension's own calls: **Total Calls**, **Cache Hit Rate**, **Avg Duration**, **Error Rate**, and, when known, **SF API Limit** (used and total, from the usage header Salesforce sends back on API responses for the org you are connected to). A banner appears when that usage passes 80% or 90%. **Limit Forecast.** When the org's Daily API Requests limit is known and the extension has made calls in the last 24 hours, it shows roughly how long until the daily limit runs out, a **24h projection** percentage, and a trend (**Rising**, **Declining** or **Stable**). The rate is a weighted average of the extension's calls over the last six hours, the latest hour weighted highest. **24-Hour Call Volume.** A line chart of the extension's calls per hour. **Org API Limits.** Bars for seven limits, when the org reports them: Daily API Requests, Daily Bulk API Requests, Concurrent Long Transactions, Daily Async Apex, Hourly Dashboard Results, Hourly OData Callouts and Streaming API Clients. Each shows used, maximum and percent; amber above 70%, red above 90%. The full table lists every limit with **Used**, **Max**, **Remaining** and **Usage**, highest usage first. **Calls by Endpoint** lists the 15 endpoints the extension called most. **Calls by Source** appears when more than one module made calls. **Cache Performance** shows **Hits**, **Misses**, **Entries** and **Hit Rate**. A hit is a read answered from the extension's cache without calling Salesforce. **Top API Consumers.** The ten client IDs with the most API requests in the org's API event log files. The panel notes this data can be up to 24 hours old. **Recent Calls.** The latest 50 calls the extension made, newest first: **Time**, **Method**, **Request** (the endpoint, the SOQL of a query, and Salesforce's error text when a call failed), **Status**, **Duration**, **Source** and **Cached**. ### What it reads and writes - The org's limits from the REST `/limits` resource: about once a minute while the numbers move, slowing to every five minutes when they don't. - For Top API Consumers: up to five Event Log Files of type API from the last day, downloaded and counted by client ID. This starts every 5 minutes and slows to every 30. - Everything else comes from the extension's own record of its calls, which needs no Salesforce call. It changes nothing in the org. No Salesforce reads run while the tab is hidden, and reading stops after a limit, session or permission error until you click **Refresh** or Retry. ### Limits - **The call log, the forecast and the call volume chart cover only SFDC Police's own calls**, not traffic from other apps and integrations. The org-wide picture is the limits panel and the SF API Limit card. - The call log keeps up to 1,000 calls in memory and saves the latest 500 for the browser session; calls older than 24 hours are dropped when the extension restarts. Calls to every org you used are counted together. - The forecast counts calls answered from the cache too, so it can overstate how fast the limit is being used. - **Top API Consumers** needs Event Monitoring. If the query for the log files fails for any reason, the panel shows **Requires Event Monitoring license (Shield or add-on)**, so that message does not prove a license is missing. - The reads of `/limits` and the event log files are API calls too; they appear in the call log under the source api-dashboard. ### Related - [REST API Explorer](https://www.sfdcpolice.com/docs/features/rest-api-explorer) - [Event Monitor](https://www.sfdcpolice.com/docs/features/event-monitor) - [Mission Control](https://www.sfdcpolice.com/docs/features/org-health) ## Import from Excel (Apply Changes) Source: https://www.sfdcpolice.com/docs/features/apply-changes > Upload an edited Permission Matrix Excel file, review the differences from your org, and push the object and field permission changes you select. Import from Excel pushes permission edits made in Excel. Export the [Permission Matrix](https://www.sfdcpolice.com/docs/features/data-dictionary) (called Data Dictionary in versions up to 1.1.13) to Excel, change the permissions in the file, and upload it here. It compares the file with your org, shows what is different, and pushes the changes you select. Where to find it: in the release after 1.1.13, open **Permission Matrix** and choose the **Import from Excel** tab, next to **Matrix**. In version 1.1.13 and earlier it is its own page, **Apply Changes**, in the sidebar. The flow is the same in both; old Apply Changes links open the new tab. The rest of this page calls it Apply Changes, the name in the current store version. *Top screenshot: 1 Drop an exported .xlsx file here, or click to browse. 2 Show Transaction History.* ### Features #### Change Review After you upload the `.xlsx` file, you see every difference between the file and the org: - Object permission changes - Field-level security changes Only settings that already exist in the org can change: if the permission set or profile has no permission row for that object or field (usually because it gives no access to it at all), that change is skipped. To grant access for the first time, use edit mode in the matrix instead. Blank cells in the file are ignored, not read as "no access". Type permissions the way the export writes them, letters together (for example `CRED` for an object, `RE` for a field). In version 1.1.13 a cell that isn't written that way, such as `R E`, `Read` or FALSE, is read wrongly: `R E` as no access at all, and `Read` as Read, Edit and Delete. Check the **Current** and **New** columns before you deploy. In the release after 1.1.13 such a cell is skipped and listed instead. You also see which permission sets and profiles change, with a count, and a warning when a profile changes, because a profile change affects every user on that profile. If the uploaded file has nothing different from the org, the page shows nothing in version 1.1.13. In the release after 1.1.13 it says "No differences", which means everything the file can change already matches the org. In the release after 1.1.13, the extra sheets of a Permission Matrix export (System Permissions, Setup Access, Record Types & Layouts and About this export) are ignored. ![Apply Changes after uploading an edited file: one object change, Edit on Account for the Sales Agreements permission set, from not granted to granted, with the Deploy 1 Change button](https://www.sfdcpolice.com/docs/shots/apply-changes-2.png) *1 The uploaded file. 2 How many object and field changes it holds. 3 Show all, object or field changes. 4 The current value in the org. 5 The value in the file. 6 Deploy the ticked changes.* #### Selective Deployment You don't have to push everything at once: - Check or uncheck individual changes - Filter to object or field changes, or search the list - Changes go to the org you are connected to. Try them in a sandbox first. #### Deployment Apply Changes updates the permission records (ObjectPermissions and FieldPermissions) through the Salesforce REST API. No XML, no Change Sets. If a profile changes, you must type `DEPLOY` to confirm. #### Results and Log - The results screen shows how many rows succeeded and lists each failed change with Salesforce's error. - Successful changes are also listed in Access Editor's **Transaction History**, stored in this browser only: the time, the action, the status and a short summary. The User column shows the org Id, not the person who made the change. #### Undo Keep an unedited copy of the exported file: uploading it again pushes the old values back. That works in every version. A push is also listed in **Access Editor → Transaction History**, with the old values of each row: - A push of up to 25 rows of one kind (object or field permissions) is logged row by row, and **Rollback** puts a row back. - A larger push is logged as one entry. In version 1.1.9, rolling that entry back can show as done without anything changing, so check the values in Salesforce. From version 1.1.13 it is refused instead, with nothing changed. In the release after 1.1.13 it is reversed all or nothing, up to 200 rows. Rows that failed were never written, so there is nothing to undo for them. ### Best Practices - Apply to a sandbox before production - Check which profiles change: a profile change affects all of its users - Keep the exported and edited Excel files as your record of the change - Pair with Persona Simulator to verify changes after the push ## Batch Manager Source: https://www.sfdcpolice.com/docs/features/batch-manager > Run, schedule and watch your org's batch Apex without the Developer Console. From version 1.1.13 it also previews and creates Consumer Goods batch settings. Batch Manager (**Automation → Batch Manager**) lists the batch classes you work with, runs them, and manages scheduled Apex. For a walkthrough with screenshots and six use cases, read [Batch Manager: run, schedule and set up Consumer Goods batches](https://www.sfdcpolice.com/blog/guide-batch-manager-cg-batches). > **Version note.** Version 1.1.9, the version before 1.1.13, has the list, its tabs, **Run**, **Run All** and creating a schedule with **+**. The items marked *(from version 1.1.13)* below are not in 1.1.9. In 1.1.9, deleting or dragging a scheduled job fails with an error and leaves the job as it was. 1.1.9 also labels schedule hours as GMT, but Salesforce runs a schedule in the time zone of the user who created it, so a job created with **+** can run hours off. ### The list | Column | Meaning | |---|---| | Pin | Pinned batches form the **In Run All** list | | Batch | Label and Apex class | | Type | *Batch* (processes records in chunks) or *Scheduled* (started on a schedule) | | Size | Batch size a run uses. From version 1.1.13: *from setting* (read from the org's batch configuration) or *no setting documented* | | Schedule | When it runs. From version 1.1.13: what the org's batch settings say, one line per sales org where relevant | | Status | Idle, Queued, Processing, Completed, Failed | | Actions | Reorder (up/down), **Run**, remove from the list | Tabs: **All**, **In Run All**, **Scheduled**, **Running**, **Failed**. **Refresh** re-reads the list. While a job is running, the list re-reads it on its own. From version 1.1.13 it does this only while the tab is visible, backing off 5/10/20/30 seconds, and otherwise says when it last read. ### Running batches - **Run** opens a dialog with the type, Apex class, description and batch size. The size is pre-filled (from version 1.1.13, from the org's setting); a size you type applies to that run only. Run Now also turns on a 60-minute debug log for you (an existing one is kept) so the run's log can be read. One click starts one run: `Database.executeBatch` for a batch, or the class's `execute()` for a *Scheduled* entry. - **Run All** starts every pinned batch one at a time, in list order, each with its usual size. Salesforce runs up to five batch jobs at once, so they are started in order, not guaranteed to finish in order. From version 1.1.13, Run All refuses to start if a batch's size can't be determined, and names it. - *(from version 1.1.13)* After a start, **Open this run's report** shows the result, errors per failed chunk, queries and limits, and (on request) the records likely changed. Figures say how many chunk logs they come from; a value that wasn't recorded shows a dash and the reason. ### Consumer Goods batches - *(from version 1.1.13)* **Add CG batches to my list** adds the known Consumer Goods batches to your list. It writes nothing to Salesforce. - *(from version 1.1.13)* **Create CG settings** previews, row by row, what it would add to the custom setting **Batch Process Configuration**: *Create* (name, class, job name, start time), *Already exists … left as it is* (existing rows are never changed) or *Not created* with the reason (for example Customer Segmentation needs a sales org). New Processing Services rows have **no days ticked**, so nothing starts until you tick days. A warning shows when no job named Scheduler is scheduled, because Processing Services run only through it. - *(from version 1.1.13)* Apex batches read only their Batch Size, from the row named as Salesforce documents. Processing Services rows are matched by Apex class and sales org, with days and a start time in GMT. ### Scheduled Apex - *(from version 1.1.13)* The **Scheduled** tab shows each job's schedule in the time zone of the user who scheduled it (a cron's hours are wall-clock hours in that zone, not GMT), the next run in your time, the previous run and who scheduled it. - **Schedule overview** shows the day in GMT. *(From version 1.1.13)* It also shows your zone, and you can drag a scheduled Apex job to a new hour to reschedule it; it is saved in your Salesforce time zone, and the dialog says if that changes the job's zone. The class is checked first (exists, has a no-argument constructor, is Schedulable); nothing is removed unless that passes, and a failure after removal restores the job. Report schedules can't be dragged. - *(from version 1.1.13)* **Delete** stops a job with `System.abortJob`, because Salesforce refuses a REST delete of a scheduled job. The Id is validated before any Apex runs. - **+** creates a new schedule (from version 1.1.13, in your Salesforce time zone). ### Related reading - [The floating panel, tab by tab](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab): the **Batch** tab runs batches and any Apex class from a record page. - [Debug Logs](https://www.sfdcpolice.com/docs/features/debug-logs): read a run's logs. ## CG Doctor Source: https://www.sfdcpolice.com/docs/features/cg-doctor > From version 1.1.13: find out why a survey question, promotion or job list does or doesn't reach a Consumer Goods Cloud visit, from the org's own records. > **Version note.** CG Doctor is available from version 1.1.13. Version 1.1.9 doesn't have it; Chrome updates the extension on its own, and **chrome://extensions** shows which version you have. For screenshots and six real use cases (missing surveys, missing promotions, job lists, rep access), read [CG Doctor: why a survey, promotion or job list does or doesn't show](https://www.sfdcpolice.com/blog/guide-cg-doctor). CG Doctor answers "why isn't X showing on this visit?" for Consumer Goods Cloud (Enhanced Data Model). It reads the org's records, applies Salesforce's documented rules, and shows every check with the values it read. It is read only. ### How to use it 1. Open **CG Doctor** and pick a visit: search by visit number, account or rep, or paste a Visit Id. 2. Choose the question: **Survey questions**, **Promotions** or **Job list people**. 3. Each item shows a verdict and the check that decided it. Expand it for every check, the values read (grouped by record, with names and links) and, for anything it can't decide, what would settle it. ### The three tabs - **Survey questions.** For each activity on the visit's template: active, approved, dates, sales org, targeting, job list, questions. Then which questions show. - **Promotions.** For each promotion that could apply: active, phase (Committed), dates against the visit, how it reaches the account, the promotion aggregation batch's store link, tactics. - **Job list people.** For each event-driven activity on the account: who should get a job list (active managers of the activity's management type whose dates overlap the activity, then the User Policy: All, Only Main or First) and who has one. Every tab also checks that **the visit's rep can read** the account and the records behind the answer, using Salesforce's own per-user access answer (sharing and object permission). ### Verdicts - **Shows / Doesn't show** (or **Right people / Wrong people**) when the data proves it. - **Can't tell** whenever the data can't: an undocumented rule, an empty value, a tie, a refused read, or device behaviour the org can't show. CG Doctor never guesses. ### Use cases - A rep says a survey question or promotion is missing from a visit. - An activity's job list went to the wrong people, or to nobody. - After changing managers, templates or dates, confirm what will reach the device. ## Config Monitor Source: https://www.sfdcpolice.com/docs/features/config-monitor > See who changed what in Setup: the latest 1,000 Setup Audit Trail entries, with search, section and user filters, change counts, and CSV export. Config Monitor answers "who changed what in Setup, and when?" It reads the org's Setup Audit Trail and shows the most recent changes in one searchable table. Open **Metadata → Config Monitor**. The page heading is **Config Change Monitor**. ### How to use it 1. Open the page. It loads the audit trail for the org you are connected to straight away. 2. Type in **Search changes…** to find a word in the change text, the action name or the section. 3. Narrow by area with **All sections**, or by person with **All users**. 4. Click a column header (**When**, **Who**, **Section**) to sort. 5. Click **Export CSV** to download the rows that match your filters. 6. Click **Refresh** to read the audit trail again. ### What you see **Counts at the top**, worked out from the entries that were loaded: - **Total changes**: how many entries were loaded (at most 1,000). - **Last 24h** and **Last 7 days**: how many of them fall in those windows. - **Busiest area**: the Setup section with the most entries. - **Most active**: the user with the most entries. **The table** has four columns: - **When**: the date and time, in your browser's local time. Newest first by default. - **Who**: the user who made the change. If Salesforce returns no name, it shows **(unknown)**. - **Section**: the Setup area Salesforce recorded for the change, or **(none)**. - **Change**: the description Salesforce recorded for the change. If there is none, the action name is shown instead, or **(no details)** if both are empty. A line above the table reads, for example, **25 of 1000 changes**, so you can see how many rows your filters keep. If the org has no entries, or your user can't read them, the page shows **No audit-trail entries**. **The CSV** is named `config-changes.csv` and has the columns Date, User, Section, Action and Detail. Dates are written as Salesforce returned them. Cells that start like a spreadsheet formula are made safe before they are written. ### What it reads and writes It runs one SOQL query on the **SetupAuditTrail** object, reading Action, Section, Display, CreatedDate and the creator's name, newest first, limited to 1,000 rows. It changes nothing in the org and stores nothing: the list is kept only while the page is open. ### Limits - **1,000 entries at most.** Only the newest 1,000 are read. If your org made more changes than that in the period you care about, older ones are not shown, and the counts (including Last 7 days) only cover what was loaded. The page subtitle notes that Salesforce keeps about 180 days of entries. - **Setup changes only.** Setup Audit Trail records changes made in Setup, not changes to record data. - **Search covers the change text, action and section**, not the user name. Use **All users** to filter by person. - **No alerts and no schedule.** It shows the trail when you open or refresh the page; it does not watch the org in the background or notify you. - **No diff.** It shows Salesforce's one-line description of each change, not the before and after values of the metadata. - If you need the changes made just before a specific failure, ranked by what to check first, use [Investigate](https://www.sfdcpolice.com/docs/features/investigate), which reads the same audit trail for a chosen time window. ### Related - [Investigate](https://www.sfdcpolice.com/docs/features/investigate) - [Process Graph](https://www.sfdcpolice.com/docs/features/org-process-graph) - [Mission Control](https://www.sfdcpolice.com/docs/features/org-health) ## Permission Matrix Source: https://www.sfdcpolice.com/docs/features/data-dictionary > Object, field and tab access for the profiles and permission sets you pick, side by side, with Excel and XML export and in-place edits. Permission Matrix (called Data Dictionary in versions up to 1.1.13) answers "what can these profiles and permission sets do?" in one grid. You pick the profiles, permission sets and permission set groups to compare, and it reads their object, field and tab settings from your org. It is not a schema browser. For one object's fields, types and relationships, use **Object Data Dictionary** in the Metadata menu. *Top screenshot: 1 Permission sets. 2 Profiles. 3 Permission set groups. 4 Muting permission sets. 5 Generate.* ### Pick what to compare Four searchable pickers sit at the top of the page: - **Permission sets** (the ones you create, not the hidden ones that belong to profiles) - **Profiles** - **Permission set groups**: each group is expanded into the permission sets it contains, and each of those gets its own column - **Muting permission sets**: in version 1.1.13 you can pick one, but it adds no column and changes nothing in the results, so the matrix does not show what a muting set removes. In the release after 1.1.13, each picked muting set gets its own read-only column marked "(mutes)", labelled with its group. A letter or "Yes" in that column is something the set removes from its own permission set group, not something it grants. A user who gets that permission another way keeps it. Muting columns are left out of the XML export. Click **Generate** to read the settings. Large orgs are read in full: there is no row cap. ![Permission Matrix result: object permissions for the Sales Agreements permission set and the CGCloud_User_Profile_Non_Sales profile](https://www.sfdcpolice.com/docs/shots/data-dictionary-2.png) *1 The Object Permissions tab. 2 Filter rows. 3 One column per permission set or profile. 4 Account: Read only, from the permission set. 5 Account: Create, Read, Edit, Delete, from the profile.* ### Read the results Version 1.1.13 has three tabs, each with a row count. The release after 1.1.13 adds three read-only tabs, for six in total. | Tab | Rows | Each cell shows | |---|---|---| | Object Permissions | One per object | `C R E D VA MA VAF`: Create, Read, Edit, Delete, View All, Modify All, View All Fields | | Field Permissions | One per field | `R E`: Read, Edit | | Tab Visibility | One per tab | The tab setting as Salesforce stores it | | System Permissions (release after 1.1.13) | One per permission that is on in at least one column | Whether that permission is on in the column. Muting columns show what the muting set removes | | Setup Access (release after 1.1.13) | One per setup item | Whether the column gives access to the item. See below | | Record Types & Layouts (release after 1.1.13) | Described below | Described below | There is one column per profile or permission set. Filter rows with the search box, and filter or sort any column. Long results scroll smoothly because only the visible rows are drawn. #### Field Permissions columns (release after 1.1.13) The Field Permissions tab has more detail in the release after 1.1.13: - **Object Name** and **Field Name** show labels. In version 1.1.13 these columns show API names. - **Data Type** shows the Salesforce type. A lookup shows what it points to, for example `reference (Account)`. Formula and roll-up fields say `calculated`. In version 1.1.13 this column is blank. - **Picklist Values** lists the active values. In version 1.1.13 this column is blank. - **Required** says Yes only when a record can't be created without the field. In version 1.1.13 this column is blank. A field that Salesforce doesn't describe to you, for example one whose feature is turned off, says "Not described". If an object couldn't be read, its cells say "Not read". Describing fields costs up to one API call per object in the matrix. The result is cached for 30 minutes. #### System Permissions (release after 1.1.13) Org-wide permissions such as Modify All Data, View Setup and API Enabled. The tab lists only the permissions that are on in at least one column, and says how many are off in all of them. Muting columns show what the muting set removes. #### Setup Access (release after 1.1.13) What each column gives access to besides objects and fields: Apex classes, Visualforce pages, custom permissions, flows, apps, connected apps, custom metadata types and custom settings, and other setup items. The tab has one row per item, with its type, name and Id, and a Type filter. When a name can't be looked up, for example an app the signed-in user can't see, or some item types, the row shows the Id and its type says "(name not read)". The name is never guessed. #### Record Types & Layouts (release after 1.1.13) - **Record types**: which record types each profile or permission set makes visible. Profiles also show the default record type, as "Visible (default)". - **Layouts**: which page layout each profile gets for each object and record type. Permission sets don't assign layouts, so their layout cells show a dash. Muting sets are left out of this tab. A column that couldn't be read says "Not read" in its cells, never "not visible". A failure in one of the three new tabs shows its reason on that tab. It does not stop the rest of the matrix. ### Export - **Download Excel**: one workbook with three sheets (Object Permissions, Field Permissions, Tab Visibility). In the release after 1.1.13 the workbook also has a System Permissions sheet, a Setup Access sheet and a Record Types & Layouts sheet. Its last sheet, **About this export**, records the org name, Id, host and type (Sandbox or Production), the signed-in user, when the values were read and when the file was exported (UTC), the extension version, the API version and what was selected. A detail that couldn't be read says "Not recorded". Apply Changes ignores these extra sheets. - **Copy CSV** and **Copy Excel** copy the tab you are on to the clipboard. - **Download XML**: Profile or PermissionSet metadata XML for each column, with a preview before you download. An edited workbook can go back into the org through [Import from Excel](https://www.sfdcpolice.com/docs/features/apply-changes): in the release after 1.1.13 it is the second tab of Permission Matrix, next to **Matrix**; in 1.1.13 and earlier it is a separate page, **Apply Changes**. ### Edit in place Turn on **Edit Mode** after generating. Click an object cell to change Create, Read, Edit, Delete, View All, Modify All or View All Fields; click a field cell to change Read or Edit. Tab visibility is read-only here, and so are the three new tabs in the release after 1.1.13. Edits wait in a pending list until you press **Push to Salesforce**, which writes them to the org's ObjectPermissions and FieldPermissions records in batches. The push is not all-or-nothing: if it stops part-way, the changes that already went through stay in Salesforce. Review the pending list before you push. ### Related - [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor): change one permission set's settings across every object and field. - [Import from Excel](https://www.sfdcpolice.com/docs/features/apply-changes) (Apply Changes in 1.1.13 and earlier): deploy an edited matrix workbook. - [Persona Simulator](https://www.sfdcpolice.com/docs/features/persona-simulator): one user's effective access from every source. ## Data Loader Source: https://www.sfdcpolice.com/docs/features/data-loader > Paste rows from a spreadsheet, map columns to fields and insert, update, upsert, delete or restore records in batches of up to 200. Data Loader runs **Insert**, **Update**, **Upsert**, **Delete** and **Undelete** on rows you paste from Excel, Numbers, Google Sheets or a CSV file. Open **Data → Data Loader**. ### How to use it 1. Under **Operation**, pick the operation, then pick the object in **Object**. 2. Optionally change **Batch size** (1 to 200, default 200) and **Threads** (1 to 10, default 6), the number of batches sent at the same time. 3. For Insert, Update and Upsert, paste your rows into **Data**. The first row is read as column headers. 4. Check the **Field mapping** grid (**Column (from paste)**, **Salesforce field**, **Sample**). Each column is matched to a field by API name or label, ignoring case, spaces and punctuation. A column with no match is set to **— Skip this column —**. You can change any mapping. On Insert, required fields are marked `*`. 5. For Upsert, pick the key in **Match on**: the record Id or an external ID field. 6. Tick **Treat blank cells as null** if blank cells should clear the field. Otherwise blank cells are left out and the field is not changed. 7. For Delete and Undelete, paste record Ids into **Record Ids** instead, separated by new lines, commas, tabs or spaces. Duplicates are counted once. For Delete, type **DELETE** in the confirm box. 8. Click the run button, for example **Insert 120**. For Undelete it says **Restore**. The run button stays disabled until at least one column is mapped. Insert also needs every required field (one that can't be blank, has no default and isn't an auto-number), Update needs the Id field, and Upsert needs the **Match on** field. If two columns map to one field, the rightmost wins and a warning says so. ### What you see While it runs, a progress line counts queued and processing batches and succeeded and failed records. **Cancel** stops new batches; batches already sent still finish. At the end, a summary says, for example, "Inserted 118 of 120 Account records · 2 failed". Upsert also counts records created and updated. Failures are grouped by Salesforce error code, such as `REQUIRED_FIELD_MISSING ×2`. **Show N rows** opens every row (#, Id, Status, Detail), **Show only failures** filters it, and **Copy failures (CSV)** copies the failed rows. ### What it reads and writes It reads the org's object list and the object's field describe. It writes through the REST API's sObject Collections endpoint, one request per batch. Insert creates records, Update changes them by Id, and Upsert creates or updates by the match field. Delete sends records to the Recycle Bin. Undelete restores them through the SOAP API's `undelete` call. It does not use the Bulk API. Each batch allows partial success, so one bad row doesn't stop the rest of its batch. The run stops sending new batches after an error that would fail every batch: an expired session, a network error, the org's API request limit, Salesforce unavailable or in maintenance, or too many requests. Rows never sent are marked `OPERATION_CANCELLED`. There is no undo, and no copy of the old values is kept. Deleted records can be restored with **Undelete** while they are in the Recycle Bin. ### Limits - At most 200 records per request. - Checkbox cells: in version 1.1.13 only the exact text `true` counts as checked. Anything else, including `TRUE` from Excel, `1` or `yes`, is written as unchecked. In the release after 1.1.13, the usual spellings of true and false (`TRUE`, `1`, `yes`, `FALSE`, `0`, `no` and so on) are read correctly, and any other value is rejected for that row instead of clearing the checkbox. - A number cell that isn't a number is sent as text, and Salesforce rejects that row. - A date-time like `2026-11-09T10:30`, with no time zone, is read as your browser's local time and converted to UTC. Other date values are sent as typed. - Address and geolocation fields can't be mapped whole; map their parts, such as street and city. - A cell containing a line break is split into separate rows, even inside quotes. - If the run stops on one of the errors above, version 1.1.13's summary marks every row as failed, including rows in batches Salesforce already saved. Check your org before running the load again. In the release after 1.1.13 the summary keeps the saved rows as successes. ### Related - [SOQL Builder](https://www.sfdcpolice.com/docs/features/soql-builder): query records first, for example to collect Ids to delete - [Data Migrator](https://www.sfdcpolice.com/docs/features/data-migrator): copy records between orgs, with a dry run and rollback - [Smart Data Generator](https://www.sfdcpolice.com/docs/features/smart-data-generator): create test records without a spreadsheet ## Data Migrator Source: https://www.sfdcpolice.com/docs/features/data-migrator > Copy records between orgs in dependency order, with a required dry run and a rollback for the records a run creates or updates. Data Migrator copies records from one Salesforce org to another, without CSV files or hand-built dependency lists. It moves records only. It also compares the two orgs' schema and permission sets so you can see gaps first, but it does not deploy fields or permissions. Two rules shape it: a dry run is required before anything is written, and the records a run creates or updates can be rolled back. ### Connecting orgs You select a **source** and a **target** org. Both connect through the Salesforce sessions you are already signed in to: no connected app and no password. Data Migrator guesses from several signals whether the two orgs are *related* (for example a sandbox and its production org) or *unrelated*, and shows the guess. For unrelated orgs it suggests a natural key to match records on. You choose the matching yourself. ### Choosing what to move Pick the objects you want to migrate. Data Migrator resolves parent-child dependencies automatically and orders the work so that parents are written before the children that reference them. This avoids the "missing reference" failures common in manual data loads. For Master-Detail and Lookup relationships, it uses `relationshipOrder` to classify the relationship correctly. A child is read only for the parents you picked. If the parent Id list is too long for one query, that filter is left out of the query. In version 1.1.9 the child may then copy rows whose parents you did not pick; from version 1.1.13 those rows are filtered out after reading and the run says the read was wider. ### Dry run first A **dry run** is required before a migration can start. It writes nothing and reports, per object: record counts, the order the objects will be written in, likely conflicts, the estimated API calls, field problems and missing references. It does not list each record. During the run, when the key you chose can't be used for an upsert and the object falls back to insert, each record is first compared with the target by that key: - **identical**: already matches, skipped - **drifted**: exists but differs; patched if **Auto-update on drift** is on (on by default for Promote, Mirror and Repair, off for Seed), otherwise reported - **missing**: not in the target; created - **ambiguous**: matches more than one target record; not written, so you can pick the right one in ErrorSurgery ### Matching records Records are matched on an **external ID** or a **composite natural key** you pick, or inserted as new. Record Ids are never used as the match key, even between related orgs. Duplicate-value errors are parsed per-row and the conflicting target Id is extracted automatically (with 15/18-character deduplication) so a single bad row does not stall the run. ### Rollback Rollback undoes inserts by deleting the created rows. Before it patches a record, it captures a **before-state snapshot**. On rollback, it PATCHes the original values back, field for field. Rollback does not bring back records a run deleted. In version 1.1.9, some lookups filled in a second pass (after the records were created) were written without a snapshot, so rollback can't undo them. From version 1.1.13, a second-pass value that can't be snapshotted is not written. ### Migration modes - **Seed** — populate an empty sandbox; reports drift rather than overwriting. - **Promote** — push changes forward; auto-patches drift. - **Mirror** — make the target match the source. - **Repair** — fix specific drifted records. ### Resilience and recovery Long migrations survive interruption. Progress is checkpointed, so a run can resume rather than restart. When records fail validation, the **ErrorSurgery** panel offers targeted resolutions — map to an existing record, remap a value, provide a default, auto-truncate an over-length field, assign to the current user, or skip — and retries only the rows you resolved. ### Walkthrough [Moving and making test data](https://www.sfdcpolice.com/blog/guide-data-migrator-and-generator) follows a real migration step by step: 41 filtered accounts sent insert-only to a second org, 1 written and 40 refused as duplicates of existing records, then a rollback that removed exactly the one record created. ### Related reading - Playbook: [Migrating orgs safely](https://www.sfdcpolice.com/docs/guides/migrating-orgs-safely) - Why the default tool falls short: [Why Change Sets fail](https://www.sfdcpolice.com/blog/why-change-sets-fail) ## Data Quality Source: https://www.sfdcpolice.com/docs/features/data-quality > Score one object's records on field fill rates, email, phone and URL format, and how long since they were last modified, with a CSV of every problem value. Data Quality gives one object a score out of 100 and lists the values that look wrong. It looks at three things: how often each field is filled in, whether email, phone and URL values have a valid shape, and which records haven't been modified in a long time. Open **Data → Data Quality**. The page is titled **Data Quality Scanner**. ### How to use it 1. Pick an object in the **Object** box (**Search an object to scan…**). 2. Check what will be measured. You don't choose these by hand; they come from the object's fields: - **Format checks** lists every email, phone and URL field, with the check each one gets. - **Completeness** says how many fields are measured for fill rate. 3. If the object has a **Last Modified Date** field, **Flag records not modified in** is ticked, with 365 days. Change the number of days, or untick it to skip the staleness check. 4. Click **Scan quality**. ### What you see The scorecard shows: - the score out of 100 - how many records were scanned - **records with issues** - a count per problem type, such as **bad email**, **bad phone** or **bad url**, shown only when there are any - **stale**: records not modified within your number of days The score is the share of scanned records that have no format problem and are not stale. A score of 90 or more is shown as good, 70 to 89 as a warning, and below 70 as bad. Fill rates are shown but do not change the score. **Field completeness** lists each measured field with a bar and the percentage of records where it is filled in, lowest first. If there are format problems, a table lists them with **Record** (a link that opens the record in Salesforce), **Field**, **Problem** and **Value**. The table shows the first 200. **Export CSV** downloads all of them to a file named after the object, such as `Account-quality-issues.csv`, with the columns RecordId, Field, Check, Value and Message. The format rules: - **Email**: one `@`, a dot in the domain followed by at least two characters, and no spaces, commas or semicolons. A field holding two addresses fails. - **Phone**: 7 to 15 digits once spaces, brackets, dashes and other formatting are removed. - **URL**: an `http://` or `https://` address, or a bare domain such as `example.com/page`, with no spaces. A blank value is never a format problem. Blanks show up in the fill rates instead. ### What it reads and writes Data Quality only reads. It reads the object's field describe, then runs one SOQL query for the record Id, Last Modified Date (when staleness is on), the email, phone and URL fields, and the fields measured for fill rate. The scoring runs in your browser. Nothing is written to your org. ### Limits - A scan reads at most 2,000 records, with no sort order. When it hits that cap, the scanned count says "capped 2000". On a larger object the score describes those records only. - Fill rates cover the first 50 fields in the order Salesforce's describe returns them. That list includes system fields such as Id, so it may not include the fields you care about most. You can't pick the fields. - Checkbox fields always count as filled in, because unticked is still a value. - Address, geolocation, encrypted and binary fields are not measured. - Format checks run only on fields whose type is email, phone or URL. A text field that holds email addresses is not checked. - Stale records are counted but not listed, and they are not in the CSV. - The phone check counts digits only. It doesn't check country codes or area codes. ### Related - [Duplicate Finder](https://www.sfdcpolice.com/docs/features/duplicate-finder): find and merge records that were entered twice - [Data Loader](https://www.sfdcpolice.com/docs/features/data-loader): fix the values you exported by pasting them back as an update - [SOQL Builder](https://www.sfdcpolice.com/docs/features/soql-builder): query the records behind a problem ## Debug Logs Source: https://www.sfdcpolice.com/docs/features/debug-logs > View, filter, and analyze Salesforce debug logs without leaving your browser. The Debug Log viewer lists the debug logs in your org, opens them in a searchable viewer, and parses them into a structured timeline. You don't have to download files and search them by hand. ### Features #### Log List List the debug logs in your org, with time, action, user, request, status, duration and size: - Filter by user Id and date range - Filter by status (success or error), minimum duration and minimum size - Filter by operation text (for example Batch or Future) - Set how many logs to load - Sort by time, action, request, status, duration or size - Search inside the body of every listed log - Download or delete one log, or delete the selected logs #### Log Viewer Click any log to open it in the viewer: - Error lines in red, warnings in amber, debug and limit lines marked - Search, with optional regular expressions - Line filters that keep only USER_DEBUG, exceptions, SOQL, DML, limits, callouts, flow or validation rule lines - **Structured view**: a timeline of SOQL, DML, debug lines, limits and automation events that you can filter by type, with the time each query and DML operation took #### SOQL Analysis The structured view picks out the SOQL queries in the log: - Total queries and total query time for the log - Row counts for each query - Limit usage bars from the log's limit lines: amber at 70%, red at 90% - The SOQL text, with buttons to copy it or run it in the SOQL Runner #### Error Highlighting - Lines with `FATAL_ERROR` or `|ERROR|` show in red - The **Exceptions**, **DML** and **Validation Rules** line filters keep just those lines - The structured view warns when a governor limit is at 80% or more #### Download Download any log as a `.log` file for sharing or archiving. ### Setting Up Debug Logs To capture a debug log: 1. Go to **Setup > Debug Logs** in Salesforce 2. Add a traced entity (user or automated process) 3. Set your log level 4. Reproduce the issue 5. Open SFDC Police → Debug Logs to view the result Or add a trace flag in SFDC Police: in Debug Logs, open the **Trace Flags** tab and fill in the **New Trace Flag** form (a user and a duration from 30 minutes to 24 hours), then click **Create Trace Flag**, or turn tracing on from a user in the floating panel. ![The Trace Flags tab of Debug Logs, with the New Trace Flag form and the list of expired trace flags](https://www.sfdcpolice.com/docs/shots/debug-logs-2.png) *1 The Trace Flags tab. 2 User ID. 3 Debug Level. 4 Duration. 5 The Create Trace Flag button.* ## Duplicate Finder Source: https://www.sfdcpolice.com/docs/features/duplicate-finder > Find groups of likely-duplicate records by comparing text, email, phone or URL fields, then merge each group or keep one record and delete the rest. Duplicate Finder looks for records that were probably entered twice, such as "Acme Inc." and "ACME, Inc". Finding duplicates only reads data. Resolving a group is a separate step that changes your org: it merges the records or deletes the extra ones. Open **Data → Duplicate Finder**. ### How to use it 1. Pick an object in **Object**. 2. Under **Match on field(s)**, tick the fields to compare. Only text, text area, email, phone and URL fields are listed. **Name** is ticked by default when the object has one. 3. For each ticked field, choose **Fuzzy** (a 0 to 100% similarity score, Jaro-Winkler, so small typos still match), **Exact** (identical after cleanup) or **Phonetic** (same Soundex code, so they sound alike). Cleanup lowercases values and removes accents and punctuation. 4. In **Match when**, choose **Average similarity ≥ threshold**, **All fields match** or **Any field matches**. 5. Set the **Fuzzy similarity** slider, from 60% to 100% (default 85%). 6. Tick **Company names (ignore Inc/LLC/Corp…)** to drop endings such as Inc, LLC, Ltd, Corp and GmbH before comparing. It is on by default for Account. 7. Click **Find duplicates**. A field blank on both records is skipped for that pair. Groups chain: if A matches B and B matches C, all three land in one group. ### What you see The header shows **Groups**, **Affected records**, **Scanned** and **Object**. Each group shows its record count and a **% match**, which averages the similarity scores of matching record pairs in the group. Highest matches come first. Each group lists the record Id and your match fields, with a link to open each record in Salesforce. With no matches, the page says **No duplicates found**. ### Resolving a group Click **Resolve** on a group. The window re-reads the records and shows: - **Choose the survivor**: the record to keep, marked **KEEP**. By default, the record with the most filled-in fields. - **Conflicting fields**: each field whose value differs. Pick the value the survivor keeps. - A preview, for example "Keep 1 record, merge 2 · apply 3 field changes to the survivor". For Account, Contact and Lead you choose a strategy: - **Native merge**: Salesforce reparents the losers' child records to the survivor, then deletes the losers. - **Keep master + delete losers**: no reparenting; the losers go to the Recycle Bin. Other objects get only the second strategy, with a warning that child records are not moved. Type **MERGE**, then click **Merge records** (native merge) or **Merge & delete losers**. ### What it reads and writes The scan is one SOQL query for the record Id and your match fields, limited to 2,000 records. The comparison runs in your browser. Resolving re-reads the group's records, up to 140 editable fields. - **Native merge** uses the SOAP API `merge` call, which takes the survivor and up to two losers. Larger groups take several calls in a row, and the calls stop at the first failure. Your field choices are sent as values on the survivor. - **Keep master + delete losers** first updates the survivor with your choices through the REST API. If that update fails, nothing is deleted. Then it deletes the losers. The extension has no undo for either strategy. Losers deleted by the second strategy can be restored from the Recycle Bin. ### Limits - A scan reads at most 2,000 records, in no set order. Past that, the results say **capped at 2000** and duplicates among the other records are not found. - The resolve window compares and copies at most 140 editable fields. Address, geolocation, encrypted and binary fields are left out. - With **Native merge**, picking **(blank)** for a conflicting field does not clear it; the survivor keeps its own value. - You resolve one group at a time. Resolved groups are hidden until you scan again. ### Related - [Data Quality](https://www.sfdcpolice.com/docs/features/data-quality): score an object for missing values and bad email, phone and URL formats - [Related Records](https://www.sfdcpolice.com/docs/features/related-records): see what is connected to a record before you merge or delete it - [SOQL Builder](https://www.sfdcpolice.com/docs/features/soql-builder): query the records in a group in more detail ## Event Monitor Source: https://www.sfdcpolice.com/docs/features/event-monitor > Browse and read your org's event log files, and manage PushTopics, from the browser. Event Monitor reads Salesforce **event log files**: the daily (or hourly) CSV files Salesforce writes for logins, API calls, report exports, Apex runs and other activity. It also includes a small **PushTopic manager**. It does not stream events live. It does not subscribe to Platform Events or Change Data Capture channels. ### Before you start Most event types need Salesforce's **Event Monitoring** add-on; Salesforce makes a few available without it. If your org can't read event log files at all, the page says the add-on is needed instead of showing an empty list. ### Find a log file 1. Choose how far back to look: 1, 3, 7, 14 or 30 days. 2. Optionally choose an event type, such as Login, API or ReportExport. 3. Click **Fetch Logs**. You get the newest 200 matching files, each with its event type, date and size. ### Read a log file Click a file to download and read it in your browser. The first 100 rows are shown as a table, with a note of how many rows the file has in total. Nothing is sent anywhere except to your own org. ### Manage PushTopics PushTopics are Salesforce's older streaming setup, still used by some integrations. The PushTopic manager lists your org's PushTopics and lets you create, edit and delete them: the query, API version, whether it is active, which fields trigger a notification, and which operations (create, update, delete, undelete) it notifies for. Delete asks you to click a second time to confirm. For new work Salesforce recommends Platform Events or Change Data Capture instead; the page says the same. ## Field Creator Source: https://www.sfdcpolice.com/docs/features/field-creator > Create several custom fields on one object in a single run, grant each one field-level security, and add them to the page layouts you pick. Field Creator creates custom fields from a form in one run. It can also grant field-level security (FLS) on permission sets and profiles and add the fields to page layouts. Open **Metadata → Field Creator**. The page notes that you need **Customize Application**, plus permission to manage profiles and permission sets for FLS. ### How to use it 1. **1 · Object**: pick the object. 2. **2 · Add a field**: fill in **Label**, **API name** and **Type**, then click **Add field**. The API name comes from the label (characters other than letters and digits become underscores; a leading digit gets an `X` in front), and you can type your own. The full name, such as `Account.Score__c`, shows next to the button. The types are Text, TextArea, LongTextArea, Number, Currency, Percent, Checkbox, Date, DateTime, Email, Phone, Url, Picklist and Multipicklist. Depending on the type you also get **Length**, **Precision**, **Scale**, **Default**, **Checked by default**, **Required** and **Picklist values (one per line)**. **Description** and **Help text** are optional. 3. **3 · Fields to create** lists what you added, with a trash icon to remove one. 4. **4 · Field-level security (optional)**: expand a field and tick its **Permission sets** and **Profiles**. Tick **Also grant Edit** for read and edit; otherwise access is read-only. **Apply these targets to all fields** copies one field's choices to the rest. A field with no targets gets no FLS on any permission set or profile. 5. **5 · Page layouts (optional)**: tick **Layouts**. Under **Target section per layout**, keep **Auto — last field section** or pick a section. Tick **Place as read-only** to add the fields read-only. 6. Click **Create N fields**. **Add field** checks the field first: the API name must start with a letter and use only letters, digits and underscores, scale can't exceed precision, and a picklist needs a value. ### What you see The result panel shows "Result — N created, M failed" and one row per field: **created**, or Salesforce's error. Then an FLS line, such as "Granted field-level security on 6 rows across 2 fields", with the failure count and first error if rows failed. Then one line per layout: fields added and fields already present, or the error. Created fields leave the list; failed ones stay so you can fix them. ### What it reads and writes It reads the object list, permission sets (`PermissionSet` where `IsOwnedByProfile = false`), the permission sets behind profiles, and the object's page layouts (Tooling API). Clicking **Create** writes right away; there is no confirm step. 1. **Fields**: each field is created on its own through the Tooling API (`CustomField`), so one failure doesn't stop the others. 2. **FLS**: for the created fields only, one `FieldPermissions` record per field and target is inserted through the REST API, in batches of 200. Read is always granted; Edit only if you ticked it. 3. **Layouts**: each chosen layout's metadata is read, fields not already on it are added to the target section, and the layout is saved back through the Tooling API. Required fields are placed as required; others as read-only or editable, following **Place as read-only**. One layout failing doesn't stop the others. There is no undo: created fields stay until you delete them in Setup. Saved defaults: Text length 255; LongTextArea length 32,768 with 3 visible lines; Number, Currency and Percent precision 18, scale 0. A Text default is saved as a text value. Checkbox is always saved with a default (checked or not). Picklist and Multipicklist are restricted, keep your order and have no default value. ### Limits - Only the 14 types above. Lookup, master-detail, formula, roll-up summary, auto-number, rich text and other types are not offered. - In version 1.1.13 the **Default** box shown for Number, Currency and Percent is not saved; only a Text default is. In the release after 1.1.13 a number default is saved. - Lengths and precision aren't checked against Salesforce's maximums; Salesforce's error shows in that field's result. - A picklist value containing a semicolon is split into two values. - The list keeps its fields when you switch objects, but the layouts shown are always the current object's. Create one object's fields at a time. - In version 1.1.13, adding fields to page layouts writes them under their full name (`Account.Score__c`), while a layout names its fields without the object (`Score__c`), so the fields may not be placed correctly. Check the layouts afterwards, or add the fields in Setup. Fixed in the release after 1.1.13. ### Related - [Object Data Dictionary](https://www.sfdcpolice.com/docs/features/object-data-dictionary): check the fields an object already has - [Permission Matrix](https://www.sfdcpolice.com/docs/features/data-dictionary): review field-level security after you create fields - [Permission Sets vs Profiles](https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles): where to grant access ## Floating Panel Tools Source: https://www.sfdcpolice.com/docs/features/floating-panel > Every tab of the floating panel: Actions, Access (record and user), Query, History, Move (Beam), Batch and Status. The floating panel opens on any Salesforce page: click the SFDC Police icon in Chrome's toolbar (click again, press Escape or use ✕ to close). It knows the org and the record you are on, and every tab follows you to the next record. Five tabs are visible; **Batch** and **Status** are behind **⋯**. A red PRODUCTION strip shows in production orgs. For screenshots and use cases for every tab, read [The floating panel, tab by tab](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab). ### Actions What you are on, plus **Copy Id**, **Copy link**, **Fields** (this record's values by API name), **Describe** (the object's describe) and **Schema** (related objects), all shown in the panel. **Suggested here** lists the tools that fit the page (on a record: Related Records, SOQL Builder, Org Process Graph); **All tools** lists every tool. ### Access → Record 1. Open **Access X-Ray** and search for and pick a user. (From version 1.1.13 this section is called **Check a user's access to this record**.) 2. Access X-Ray shows the verdict (Read / Edit / Create / Delete) and about ten layers: object permissions, org-wide default, ownership, role hierarchy, sharing rules, system bypass permissions (View All / Modify All), Salesforce's record-access verdict, field-level security, page layout and record type access. Read, Edit and Delete come from Salesforce's `UserRecordAccess`. Create comes from the user's object permissions. If `UserRecordAccess` returns nothing, the verdict uses object permissions only and a warning says so. 3. Click the same control again to collapse it (from version 1.1.13: **Hide access check**); the **✕** in the search box checks another user. The tab also shows the object, Id and key prefix (with copy buttons), shortcuts to the object's fields, record types, list view and access settings, and the owner, record type, created and modified details. From version 1.1.13, **Look up another object** at the bottom shows another object's details; it lists up to 50 matches and hides Share/Feed/History/ChangeEvent objects unless you type those words. ### Access → User Search a user to see name, username, email, profile, status, last login and user Id, with **Edit User**, **Enable Debug**, **View Logs**, **Reset Password** (asks to confirm) and **Open in Access Editor**. ### Query A SOQL editor pre-filled with this record's query. Run with ⌘↵ / Ctrl+Enter or **Run**; **Builder ↗** opens it in SOQL Builder. From version 1.1.13, **Related queries** suggests queries for the record's related objects, grouped as *Linked through a junction object* (one IN query per route, for example an account's customer sets), *Child records* and *Parent records*. Filter the list, click a suggestion to put it in the editor, adjust it, then **Run**; nothing runs until you do. Owner and audit lookups, polymorphic lookups and system objects (Share, History, Feed) are left out. Junction routes are looked for in up to 30 child objects (custom objects first), so a large object may not show every route. ### History - **My actions**: changes you made through SFDC Police (record edits, permission set assignments, object and field permissions). - **Record trail**: **Capture run log** (turns on debug logging for you; save the record to capture what automation ran), the object's automations (active and inactive), **Field Change History** for tracked fields, and a link to Process Graph. ### Move (Beam) 1. Pick the target org (listed as "Org name · host"; open the org in another tab and press refresh if it is missing). 2. Choose **Include parent hierarchy** and **Include child records**, or **Import all related** to turn on parents, children and a full scan and analyze in one click. 3. **Analyze move** and review the plan: each record is marked **create**, **reuse** or **upsert**, with how many fields are copied. You can change the choice per record (**Upsert · field**, **Reuse existing** or **Create new**). 4. Click **Beam**. The panel reports how many records were created and reused. **Undo** deletes the records Beam created. **What Beam changes in the target org.** Beam can update records that already exist there. It picks the action for each record like this: - **Upsert** (the default when the source record has an external ID value): Beam upserts on that external ID field. If a target record has the same external ID, Salesforce **updates it with the source values**. If none matches, a new record is created. - **Reuse**: a target record with the same Name is used as it is. Beam does not change it. - **Create**: a new record is created. Check the plan before you click **Beam**, and switch a record to **Create new** if you do not want a target record changed. **Undo** only deletes records Beam created; it does not reverse updates made by an upsert. An upsert that updated a target record is counted as reused. A warning shows when the target is a production org. ### Batch **Batches** lists your Batch Manager batches with status, schedule and size, a **Run** per batch and **Run all**. **Run Apex** searches any Apex class, works out how it can be started (batch, queueable, schedulable, static method or constructor), runs it and can link the debug log. See [Batch Manager](https://www.sfdcpolice.com/docs/features/batch-manager). ### Status Connection, signed-in user, org name, Id, instance, domain and type, API calls made by SFDC Police (and how many came from cache), the org's API usage against its daily limit, and **View API Dashboard**. ## Flow Hub Source: https://www.sfdcpolice.com/docs/features/flow-scanner > Check your active Salesforce flows for common anti-patterns and performance risks, read what each flow does, and see its versions. Flow Hub checks your org's active flows for common anti-patterns and performance risks before they cause problems in production. It is static analysis: it reads each flow's metadata and does not run the flow. ### Features #### Flow List Flow Hub lists your org's active flows (up to 200, sorted by name; search by name to find others). Each row shows: - The flow's name, with a link to open it in Salesforce - Flow type (Screen, Auto-Launched, and so on). Salesforce stores record-triggered and schedule-triggered flows as auto-launched, so they show as Auto-Launched. - A dot coloured by risk level (hover it to read the level), and the flow's test coverage when Salesforce has it You can select flows and deactivate them; Flow Hub asks you to confirm first. #### Flow Details Open a flow to see four tabs: - **Overview** — a step-by-step text summary of what the flow does - **Health** — the findings from the checks below - **Risk** — the trigger type and object, a risk level, and how many elements of each kind (decisions, creates, updates, deletes, actions, screens) the flow has - **Versions** — the flow's versions ![The Risk tab of a screen flow in Flow Hub, showing trigger, risk level, flow elements and subflow dependencies](https://www.sfdcpolice.com/docs/shots/flow-scanner-2.png) *1 The Risk tab. 2 Trigger type and trigger object (dashes for this flow). 3 Risk level. 4 Flow elements. 5 Subflow dependencies. 6 Open in Salesforce.* #### Checks Flow Hub checks each flow for: ##### Performance - SOQL queries inside loops - DML operations inside loops - Record-triggered flows with many DML or query elements (more than 5 in total) - Too many elements (more than 50) ##### Anti-patterns - Hardcoded record IDs - Unused variables - More than 8 decision elements in one flow - Updates to the object that triggers the flow (risk of re-triggering) - Triggered flows with no entry conditions - `IsChanged()` in a scheduled path, where it does not work - A missing flow description ##### Reliability - Data operations and actions with no fault path - Get Records results that may not be checked for null (flagged when a Get Records element has no fault path) ##### Screen flows - Delete elements in a screen flow #### Issue Severity Each finding is grouped as: - **Errors** — likely to cause errors or data problems - **Warnings** — may cause problems under some conditions - **Info** — a best-practice suggestion ### Interpreting Results Not every finding needs immediate action. Use the groups as a guide: - Fix **Errors** before release - Review **Warnings** and decide based on context - **Info** items are improvements, not blockers ## Investigate Source: https://www.sfdcpolice.com/docs/features/investigate > Something broke in Salesforce? Pick the symptom and see the Setup and automation changes made before it, ranked by what to check first, with the evidence. Investigate answers "something broke: what changed before it?" It reads the org's saved evidence and recent Setup changes, then ranks the changes by what to check first, with the reasons. The ranking is fixed rules with points, not AI. Open **Investigate** in the main menu. ### How to use it 1. Under **What broke?**, pick a **Symptom**: - **A flow is failing**: type in **Find the flow**, click **Search**, then click the flow. - **A save fails with a validation error**: enter the **Object API name** and paste the **Error message**. - **A field isn't being updated**: enter the **Object API name** and **Field API name**. 2. Optionally set **When did it start? (optional)**. 3. In **Setup changes to read**, pick 1, 3, 7, 14, 30, 90 or 180 days before. 4. Click **Investigate**. 5. In **What to check first**, click a row to see **Why it ranked here**. ### What you see **What to check first.** Each row shows the change, its kind (such as Validation rule, Permission or Flow), when and how long before the failure, who made it, and its points with the signals that earned them, such as "Changed the failing flow" or "Exact error message match". A signal that can't be decided shows as "can't tell" and earns nothing. The table exports to CSV or JSON. **The window** ends at the earliest known failure time (the oldest saved failed run or the start you entered, whichever is earlier), or now if neither is known, and reaches back the days you chose. Changes after the failure are not read. **Per symptom:** - **A flow is failing**: **The failure** as Salesforce saved it, a **Version comparison** of the failing version with the one before it, and **Depends on**. - **A save fails with a validation error**: the object's validation rules, matched against the message you pasted. - **A field isn't being updated**: the field's type, whether it is updateable or a formula, the automations found that write it, and the save-order verdict from the [Process Graph](https://www.sfdcpolice.com/docs/features/org-process-graph) engine. **Timeline** orders changes and failures in time. **What was and wasn't checked** lists each source read, read in part, or refused. **Export** offers **Copy as Markdown** and **Download .md**. **Notes** holds up to 5,000 characters of your own notes. ### What it reads and writes From the org you are connected to, it reads: - Setup Audit Trail entries in the window. - Failing flow: the flow and its versions, failed runs (FlowInterview rows with status Error), the metadata of up to three versions (Tooling API), up to three other flows changed in the window, and describes of up to two objects. - Validation error: the object's validation rules (Tooling API), the formulas of up to 25, and the names of their last editors. - Field not updating: flows triggered on the object (up to 200), active Apex triggers on it (up to 50), workflow field updates on it (up to 50), and the object's describe. It changes nothing in the org. Before a run it estimates the API calls the run can make and stops if that is more than 95% of the org's remaining daily calls. Notes are saved only in your browser, per org and per flow or object; **Clear** deletes them after a **Delete these notes?** confirmation. ### Limits - At most 2,000 Setup changes (those closest to the failure) and 2,000 failed runs (the oldest) are read; the page says when a limit was hit. - Setup Audit Trail records Setup changes only, not changes to record data. - Salesforce does not save every failed flow run, so "no failed runs" is shown as a coverage fact, not as "nothing is wrong". If Salesforce refuses to return them, the page says they were not checked. - Salesforce hides the metadata of flows installed from a managed package, so their versions can't be compared. - For a field not updating, flows are found by the object they are triggered on, and an Apex trigger counts as a writer when its code contains the field name. A flow on another object that updates this field is not found. ### Related - [Config Monitor](https://www.sfdcpolice.com/docs/features/config-monitor) - [Process Graph](https://www.sfdcpolice.com/docs/features/org-process-graph) - [Debug Logs](https://www.sfdcpolice.com/docs/features/debug-logs) ## Metadata Peek Source: https://www.sfdcpolice.com/docs/features/metadata-peek > Search your org's metadata by name and see each item's details on one page, without opening Setup or downloading packages. Metadata Peek is a full-page search for your org's metadata. Type a name, pick a result, and see its details next to the search. It covers many metadata types, including objects, Apex, flows, Lightning web components and Visualforce pages, without opening Setup or deploying a package. ### Features #### Object Details Search an object and pick it to see: - API name, label and plural label - Key prefix, and whether it is custom or standard - Field count (total, custom and standard) - **Fields**, with a search box and an All / Custom / Standard filter (lookup fields show the object they point to) - **Relationships** (child relationships) - **Record Types** - **Validation Rules** Other types (Apex, flows, Lightning web components, Visualforce pages) have their own detail views. The rest show the item's basic details. #### Copy the API name Click **API Name** (the button with the copy icon) to copy the selected item's API name to your clipboard, which is useful when writing SOQL, Apex or integrations. #### Open in Salesforce Click **Open in Salesforce** to open the selected item in Salesforce (usually its Setup page) in a new tab. ### Field hover tooltips (a separate feature) On a Lightning record page, hovering a field label shows a tooltip. This is not part of Metadata Peek and works without opening it. The tooltip shows: - API name - Field type and length - Required / unique / external ID flags - A Formula badge for formula fields - Help text - **Who Sees?** (which users, profiles and permission sets can see the field) and **Automations** (which automations read or write it) ![A field hover tooltip on a Salesforce Account record page](https://www.sfdcpolice.com/docs/shots/metadata-peek-2.png) *1 The field label being hovered. 2 The field's API name and type. 3 The Unique flag. 4 The Who Sees? link. 5 The Automations link.* ### How to Use 1. Open **Metadata Peek** from the sidebar, or from **All tools** in the floating panel. 2. Type a name in the search box. 3. Pick a result to see its details. 4. Copy the API name, or click **Open in Salesforce**. ## Object Data Dictionary Source: https://www.sfdcpolice.com/docs/features/object-data-dictionary > Pick one or more objects and get every field's type, length, required flag, picklist values, formula and help text as a table, an Excel file or a CSV. Object Data Dictionary lists the fields of the objects you pick, one row per field, and exports that list to Excel or CSV. Use it to document a schema or to answer "what fields does this object have?" without opening each field in Setup. Open **Metadata → Object Data Dictionary**. This page is about fields. For who can see and edit each field, use the [Permission Matrix](https://www.sfdcpolice.com/docs/features/data-dictionary). ### How to use it 1. Under **Select Objects**, tick the objects you want. Use **Search objects...** to find them by label or API name. Each object is tagged **Custom** or **Standard**. 2. Click **Generate Metadata**. The page shows "Fetching metadata..." while it reads the objects. 3. Review the table under **Field Metadata**. Use **Search fields...** to filter it, and the column menu to show or hide columns. 4. Click **Download Excel** or **Download CSV**. 5. Click **Clear All** to start over. ### What you see The heading says how many fields were found across how many objects, for example "312 fields from 4 objects". Each row is one field. The columns are: - **Object Name** and **Object API** - **Field Name** and **Field API** - **Data Type**: the field type Salesforce reports, such as `string`, `double` or `picklist`. Relationship fields show **Lookup** or **Master-Detail** instead of `reference`. - **Length** - **Required**: **Yes** when Salesforce says the field can't be blank - **Custom**, **External ID**, **Encrypted**, **Unique** and **Auto Number**: Yes or No - **Picklist Values**: the values' labels, separated by semicolons - **Formula**: the formula text, for formula fields - **Help Text** - **Reference To**: the object or objects a relationship field points to - **Relationship Name** The table hides Object API, Unique, Auto Number, Picklist Values, Formula, Help Text and Relationship Name at first. On Account, fields that only exist when Person Accounts are on carry a **PA** badge. The search box matches field name, field API name, object name, object API name, data type, reference target and help text. ### What it reads and writes It only reads. The object list comes from a Tooling API query on `EntityDefinition` (queryable objects, sorted by label). **Generate Metadata** runs the REST describe call for each selected object, all at once. Nothing is written to your org. Lookup and Master-Detail are told apart without using the required flag. If the parent object is among the objects you selected, the parent's child relationship decides: cascade delete means Master-Detail. Otherwise the field's relationship order decides: a value means Master-Detail, none means Lookup. The exports use the same 17 columns in the same order, whatever columns you hid in the table, and they include every row, not just the rows your search shows. The Excel file has one sheet, **Field Metadata**. Files are named with the date, such as `Object_Metadata_2026-11-09.xlsx`. Values that a spreadsheet could run as a formula are neutralized in the CSV. ### Limits - **Required** means the field can't be blank. Checkbox fields always show **Yes**, because a checkbox is never blank. So do fields that Salesforce fills in itself, such as Id and Created Date. - **Encrypted** is **Yes** only for Classic Encrypted Text fields. Shield Platform Encryption does not show here. - The object picker lists at most 2,000 objects. - The **Custom** tag in the picker is based on the `__c` suffix. Custom metadata types, platform events and other custom types with a different suffix are tagged **Standard**. - If Salesforce can't describe an object you selected, that object is left out of the results and no error is shown. Compare the object count in the heading with the number you selected. - The progress count jumps from 0 to the total in one step, because all describes are sent together. ### Related - [Permission Matrix](https://www.sfdcpolice.com/docs/features/data-dictionary): field-level security for each field, by permission set and profile - [Where Used](https://www.sfdcpolice.com/docs/features/where-used): what references a custom field - [Field Creator](https://www.sfdcpolice.com/docs/features/field-creator): add new custom fields to an object ## Org Compare Source: https://www.sfdcpolice.com/docs/features/org-compare > Compare the objects and fields of two Salesforce orgs you are signed in to, and see what exists in only one org or differs between them. Org Compare shows the schema differences between two Salesforce orgs: which objects exist in only one of them, and for an object in both, which fields are missing or differ. It is useful before a deployment or a data migration between a sandbox and production. Open **Metadata → Org Compare**. ### How to use it 1. Sign in to both orgs in your browser. The **Org A** and **Org B** lists show the orgs where your Salesforce session is still live. Sandboxes are marked **(sandbox)**. 2. Pick one org in **Org A** and a different one in **Org B**. The swap button between them exchanges the two. 3. Click **Compare objects**. 4. Use the filter chips to choose what to show: **Differences** (the default), **All**, **Only A**, **Only B**, **Changed** or **Same**. 5. Click an object that exists in both orgs to compare its fields. Click **Back to objects** to return. 6. Click **Export CSV** on the object list, or **Export** on the field list, to download the rows the current filter shows. If fewer than two orgs are available, the page says **Connect a second org**. Open the other org in a browser tab and click **Refresh orgs**. ### What you see **Objects.** Counts for **Only in A**, **Only in B**, **Changed** and **Same**, then a table with each object's API name, label and status. An object is **Changed** when its label differs between the orgs; Org Compare compares nothing else at the object level. Objects are matched by API name, ignoring upper and lower case. **Fields.** For the chosen object, a table with each field's API name, its status, its type and length in each org, and a **Changes** column. A field is **Changed** when any of these differ: - type - length - nillable (whether the field can be blank) - unique - referenceTo (the objects a lookup points to) - picklist values (the API values, in any order) Each change shows the Org A value and the Org B value, for example `length: 80 → 255`. Field labels, help text, descriptions and formulas are not compared. ### What it reads and writes Org Compare only reads. For each org it calls the REST describe endpoints with that org's own session: the global describe (`/sobjects`) for the object list, and the object describe (`/sobjects//describe`) when you open an object. It does not change anything in either org. ### Limits - It compares schema from describe calls only. Flows, Apex, layouts, permission sets and other metadata are not compared. - Describe returns what your user can see in each org, so different users or permissions in the two orgs can show up as differences. - Only objects that exist in both orgs can be opened for a field comparison. - Both orgs need a live session in the browser. An org you have signed out of doesn't appear in the lists. - Changing either org, or swapping them, clears the current results. ### Related - [Data Migrator](https://www.sfdcpolice.com/docs/features/data-migrator) - [Migrating orgs safely](https://www.sfdcpolice.com/docs/guides/migrating-orgs-safely) - [Why Change Sets Fail, and How to Move the Records They Can't](https://www.sfdcpolice.com/blog/why-change-sets-fail) ## Mission Control Source: https://www.sfdcpolice.com/docs/features/org-health > One page with your org's security score and its trend, permission debt, API usage, Data Migrator status and alerts. Mission Control is the first page in SFDC Police. It shows a set of cards for the connected org: security score, permission debt, API usage, Data Migrator status, query success and alerts. The page loads them when you open it. The security score and permission debt cards have a refresh button. ### The cards - **API usage** — the org's API usage against its daily limit, with a forecast of when it may reach the limit. The limit shows after SFDC Police has made a call to the org. - **Security score** — the posture score and letter grade (the same score [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights) uses), with a trend line. - **Permission debt** — see below. - **Data Mover** — the state of your current Data Migrator job. - **Data quality** — how many of your recent SFDC Police queries succeeded or failed. It does not check the data in your org. - **Activity feed** — recent SFDC Police events, such as a new security score. - **Live alerts** — events raised while you use SFDC Police: risky permission combinations, Data Migrator errors and security grade changes. You can acknowledge, snooze (24 hours) or dismiss an alert. Permission combination alerts link to Security Insights and Access Editor. The cards are grouped by topic, not ranked by risk. ### Permission debt Permissions pile up and rarely get cleaned up. The permission debt card shows: - **Unused permission sets** — custom permission sets with no active user assigned. The debt ratio is unused sets divided by all custom sets. - **Top offenders** — permission sets with broad permissions (Modify All Data, View All Data or Manage Users), with a link to Permission Builder. - **Stale** — custom permission sets not changed in the last 2 years. - **Role mismatch** — active users who hold Modify All Data or View All Data through a permission set while their role name does not contain "admin". It checks up to 100 such assignments. ### Security score trend The security score card keeps one score per day for up to 90 days and draws them as a trend line. The history is stored in this browser, so another browser or computer starts its own trend. A score that drops after a project is a prompt to look at what changed. For the full security view (god-mode users, toxic combinations, blast radius), see [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights). ### How to use it 1. Open **Mission Control** (the first item in the sidebar). 2. Read the cards. Use a card's refresh button to load it again. 3. Clear permission debt: review unused and stale permission sets, and check the users listed under role mismatch. 4. Come back regularly (after big projects, before audits) and watch the security score trend. ### Related reading - [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights) — deep permission risk analysis. - [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain) — trace a specific permission to its source. ## Org Intelligence Source: https://www.sfdcpolice.com/docs/features/org-intelligence > Count the Apex classes, active flows, permission sets, users and validation rules in an org, with a rule-based risk grade and up to five recommendations. Org Intelligence gives you a quick count of what is in an org (Apex classes, active flows, permission sets, users, objects, validation rules) and turns a few of those counts into a risk grade and a short list of recommendations. The recommendations come from fixed rules in the extension, not from AI. Open **Develop → Org Intelligence**. ### How to use it 1. Pick an org in the org list at the top right. It starts on the org you are connected to; the list shows the orgs the extension has a session for (**Select org…** if none is chosen). 2. Click **Scan Org**. The button reads **Scanning…** while the counts load. 3. Read the cards, the gauge and the **Recommendations** list. Click **Scan Org** again to read fresh counts. Before the first scan the page shows **No snapshot yet**. ### What you see **Count cards.** Each card is one `COUNT()` query: - **Apex Classes**: Apex classes with Status Active. - **Active Flows**: flow definitions that have an active version. - **Permission Sets**: permission set records with IsCustom = true. - **Active Users**: users with IsActive = true. - **Custom Objects**: in version 1.1.13, objects Salesforce marks as customizable (EntityDefinition IsCustomizable = true), which includes standard objects you can customize, not only `__c` objects. In the release after 1.1.13 it counts `__c` objects only. - **Validation Rules**: active validation rules. **Score cards.** Two scores out of 100, from simple formulas: - **Compliance Score** starts at 100 and drops 15 points for each custom permission set that grants Modify All Data. - **Flow Health** is 100 with no active flows, then drops 5 points for every 10 active flows, never below 30. It measures how many flows you have, not whether they work. Cards turn green at 70 or more, amber at 40 to 69, red below 40. **Risk Score gauge.** A number from 0 to 100 (higher is worse) and a grade from A to F, worked out from the compliance score, the flow score and the share of custom permission sets that grant Modify All Data. A is 20 or less, F is above 80. **Recommendations.** Up to five, each with a priority (P1 to P5) and an impact (high, medium, low). The rules are: - three or more custom permission sets grant Modify All Data: review them; - more than 50 active flows: consider consolidating; - more than 40% of custom permission sets grant Modify All Data: audit them; - more than 200 active Apex classes: check test coverage; - more than 100 active validation rules: audit them; - none of the above and an overall score of 80 or more: "Org health is strong". ### What it reads and writes It runs eight `COUNT()` queries against the org: ApexClass, FlowDefinition, EntityDefinition and ValidationRule through the Tooling API, and PermissionSet (twice), User and Profile through the REST API. The Profile count is read but not shown. It changes nothing in the org. The scan is kept only on the open page: leave the page and it is gone, and nothing is saved in your browser. ### Limits - In version 1.1.13, if a count query fails (for example, your user can't read that object), the card shows **0** and no error appears, so a 0 can mean "none" or "not read", and the scores can come out better than they should. In the release after 1.1.13 a failed count shows an error naming what couldn't be counted. - The trend label under the gauge always reads **stable** in this version, because no earlier scan is kept to compare against. - The scores are counts put through fixed formulas. They do not look at code quality, test coverage, flow errors or who has which permission. - The recommendations have no buttons; they are text only. ### Related - [Mission Control](https://www.sfdcpolice.com/docs/features/org-health) - [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights) - [Flow Hub](https://www.sfdcpolice.com/docs/features/flow-scanner) ## Process Graph Source: https://www.sfdcpolice.com/docs/features/org-process-graph > The automations Process Graph can read on an object (flows, triggers, workflow rules, validation rules), in the order they run, and fields more than one writes. For the setup screen (objects, Fast or Full, Customise), the Dashboard and Map, and six use cases with screenshots, read [Process Graph: see every automation that runs when a record is saved](https://www.sfdcpolice.com/blog/guide-process-graph). When three flows, a trigger and two workflow rules all fire on the same object, the order they run in decides the outcome, and few people can recite that order from memory. Process Graph draws the automations it can read on an object, how they are wired, and where they may conflict. ### The dependency graph Process Graph draws the automations it reads on an object as an interactive graph: - record-triggered and scheduled **Flows** - **Apex triggers** - **Workflow rules** - **Validation rules** - approval processes Edges show what triggers what, so you can follow a save through the chain instead of imagining it. **What the scan reads.** Only active flows are read. **Fast** mode reads up to 100 flows and 100 Apex classes; **Full** mode reads more. When a cap is reached, a banner says so and offers to switch to Full. Anything the scan did not read is not on the graph. ### Execution order The graph models Salesforce's order of execution, so you can see the sequence automations actually run in — before-save vs after-save, triggers vs flows vs workflow. This is where order-of-operations bugs hide: a before-save flow that sets a field, overwritten by an after-save trigger, producing a result that looks impossible until you see the order on screen. ### Conflict and dead-code detection Process Graph flags problems that cause hard automation bugs: - **Dead / unused** (from version 1.1.13: **No caller found**) — automations that nothing the scan read starts or calls. Something outside the scan may still start them, so check before you delete one. - **Duplicate writers** — multiple automations writing the same field. The classic source of "this field keeps changing and I do not know why." - **Object health scoring** — a per-object signal for how tangled its automation has become. ### Impact of an automation Select an automation to see how many other automations and fields it affects downstream. Use it before you deactivate or delete something, together with your own testing. ### Documentation export Export the graph as **Mermaid** to put an automation diagram into a runbook or a pull request. It is generated from the org, so it matches what the scan read. ### Related reading - [Flow Hub](https://www.sfdcpolice.com/docs/features/flow-scanner) — best-practice checks for individual flows. - Where Used and Object Data Dictionary (in the extension's Metadata menu) — where a field is referenced, and the object's fields. ## Permission Builder Source: https://www.sfdcpolice.com/docs/features/permission-builder > Build permission sets with object and field permissions, check the objects they depend on, preview the payload, and compare two permission sets. Permission Builder creates permission sets without clicking through Setup page by page. You pick objects, set object and field permissions, check dependencies, and create the permission set in your org. *Top screenshot: 1 The tabs: Setup, Permissions, Fields, Graph, Payload. 2 Template name. 3 Object search. 4 Add Object. 5 Objects added. 6 Missing-dependency warning.* ### Features #### Permission Set Creation Permission Builder has five tabs: **Setup**, **Permissions**, **Fields**, **Graph** and **Payload**. A bar at the bottom stays on screen with the dependency check and the **Create New**, **Export XML**, **Copy JSON** and **Download** buttons. 1. **Setup**: name the template, search for objects and click **Add Object** for each one. To start from a permission set that already exists, click **Load Existing PS** at the top. 2. **Permissions**: tick the object permissions for each object (Create, Read, Edit, Delete, View All Records, Modify All Records, View All Fields). 3. **Fields**: set field permissions. 4. **Graph**: see the objects you added with the objects they relate to, as a graph or a table, so you can see what else the permissions may need. 5. **Payload**: see the Salesforce API payload that **Create New** would send, before you create anything. ![Permission Builder Permissions tab with Account and Contact rows and Create, Read, Edit, Delete, View All, Modify All and View All Fields columns](https://www.sfdcpolice.com/docs/shots/permission-builder-2.png) *1 Fields tab, for field permissions. 2 Filter objects. 3 Read ticked for Account. 4 Auto-Add for the missing dependencies. 5 Export XML, Copy JSON and Download.* When an object you picked needs another one (for example a parent object), the bottom bar says how many dependencies are missing, and **Auto-Add** adds them. ![Permission Builder Graph tab showing Account and Contact with their related objects](https://www.sfdcpolice.com/docs/shots/permission-builder-3.png) *1 Depth buttons: Direct, Extended, Full Schema. 2 Graph and Table views. 3 The objects you added (Account). 4 Export PNG.* **Create New** creates the permission set in the connected org. **Download** saves the payload as a JSON file and **Copy JSON** copies it; **Export XML** gives a `.permissionset-meta.xml` file. **Save Template** keeps your choices to reuse later. Permission Builder covers object and field permissions. It does not set system permissions, tab settings or Apex class access, and it does not assign the permission set to users. #### Side-by-Side Comparison **PS Comparison** (its own entry in the sidebar, called **Compare** from the release after 1.1.13) lets you select any two permission sets in the connected org and see their object and field permission differences in a color-coded view. Use it to: - Find gaps between similar permission sets - Check changes before deployment - See which object and field access each set grants ### Assigning permission sets Permission Builder does not assign permission sets. To assign or remove a permission set for many users at once, use the bulk operations in [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor): search and pick users, then assign or remove the set. Each assignment is recorded in the transaction log. ### Best Practices 1. **Start minimal** — create permission sets with the least access needed 2. **Use consistent naming** — follow a naming convention like `PS_[Team]_[Access]` 3. **Review quarterly** — use PS Comparison (Compare) to spot drift between similar permission sets 4. **Test in sandbox** — test permission changes in a sandbox before production ## Explain Access Source: https://www.sfdcpolice.com/docs/features/permission-chain > Trace a user's object and field access back to the profile, permission set, group or muting set behind it, see who can read a field, and compare two users. Find it in the sidebar as **Explain Access**. Up to version 1.1.13 it was called **Permission Intelligence** (and before that, Permission Chain); only the name changed, so old links and bookmarks still open it. It answers the question every admin dreads: "why does this user have this access?" It traces a user's access to an object or field back through each layer and shows the grant responsible, so you can fix the source instead of guessing. It has three modes: **Trace**, **Who Has Access** and **Compare Users**. Version 1.1.13 also has **Audit User**; in the release after 1.1.13 that check moved to [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights) → **Users** → **Check**. It only reads; it never changes permissions. *Top screenshot: 1 The user you picked. 2 Object. 3 Scope, here All Fields. 4 Trace. 5 Count of fields by access. 6 The profile or permission set that grants the access.* ### The layers it walks Effective permissions in Salesforce are the sum of several layers. Explain Access walks each of them and records where every grant comes from: - the user's **Profile** - each assigned **Permission Set** - each **Permission Set Group** the user belongs to - any **Muting Permission Set** that removes permissions inside a group Trace covers object access and field-level security. Pick a user and an object, then trace one field, every field on the object, or the object's page layouts. You see not just *whether* the user has the access, but *which* assignment grants it. "Granted via the `Sales Ops` permission set" is an answer you can act on; "they have it somehow" is not. In the release after 1.1.13, Trace has a fourth scope, **Object Permissions**: each of the seven object permissions (Create, Read, Edit, Delete, View All, Modify All, View All Fields) for the user on the object, granted or not, with every profile, permission set or group that grants it, including View All Data and Modify All Data. User and system permissions (for example API Enabled) are not traced here. > Muting permission sets are detected by key prefix (`0QM`), not by relationship name, so muted permissions are attributed correctly even where the standard relationship returns null. ### Who Has Access Run the question in reverse. Start with an object and a field, and ask **which users can read or edit it**. You get the list of users, with the grant path for each. It fits "who can see Social Security Number?" style audits. In the release after 1.1.13 it also answers for an **object permission** (for example, who can delete Accounts) and a **system permission** (for example, who has Modify All Data), with where each user gets it. ![Who Has Access listing the active users who can read Account.AnnualRevenue and how each gets it](https://www.sfdcpolice.com/docs/shots/permission-chain-2.png) *1 The Who Has Access mode. 2 Object. 3 Field. 4 Find Users. 5 The answer in one line. 6 Each user's access.* ### Compare Users Put two users side by side and see where their access differs, object by object and permission by permission. Use it to answer "what does this new hire lack compared with that rep?", or to explain why two people on the same team see different things. Comparisons download as **CSV or JSON**, or copy to the clipboard as **CSV or TSV**, so a permission difference becomes evidence you can attach to a ticket. In the release after 1.1.13 the same comparison is also the **Users** tab of [Compare](https://www.sfdcpolice.com/docs/features/ps-comparison). ### Audit User (version 1.1.13) Pick one user for a health check: risky permission combinations they hold and suggested fixes. In the release after 1.1.13 this is the **Check** button on a user in Security Insights → **Users**, with the same checks; a fix still asks before it changes anything. ### When to reach for it - A user can see something they should not: find the grant and remove it. - A user cannot do something they should: find the missing grant and add it. - Onboarding: compare a new hire with an existing user to see what is missing. - Audit: show who can reach sensitive fields, and why. ### Related reading - [Why can this user see this record?](https://www.sfdcpolice.com/blog/why-can-this-user-see-this-record) - [Persona Simulator](https://www.sfdcpolice.com/docs/features/persona-simulator): combine a profile and permission sets and see the access, page layouts and app access they give. - [Security Insights](https://www.sfdcpolice.com/docs/features/security-insights): org-wide view of risky permissions. ## Persona Simulator Source: https://www.sfdcpolice.com/docs/features/persona-simulator > Combine a profile, permission set groups and permission sets, and see the access they add up to, without logging in as anyone. The Persona Simulator shows the access a mix of profile and permission sets would give. You pick the pieces; it adds them up the way Salesforce does and shows the result as permission tables. Nobody's credentials are needed, and nothing is assigned to a real user. *Top screenshot: 1 Base profile. 2 Permission set groups. 3 A direct permission set, ticked. 4 Simulate Access.* It simulates permissions, not a real user's screen. It does not show sharing or which records someone can see. ### Why It Matters When you plan a permission change, you need to know its effect. Without the simulator, you would have to: - Log in as the user (requires their password or a reset) - Use a sandbox with a cloned user - Ask the user to test and report back With Persona Simulator, you pick a profile and permission sets and see the access they add up to. ### Features #### Build the Persona 1. Choose a **base profile**. 2. Add **permission set groups**. Muting permission sets inside a group are applied. 3. Add **direct permission sets**. 4. Click **Simulate Access**. A progress bar shows each step while the permissions load. If you arrive from another module with a user selected, the simulator pre-selects that user's profile. It does not add their permission sets; add those yourself. #### What You See The results are split into tabs: - **Object Permissions**: create, read, edit, delete, View All, Modify All and View All Fields per object - **Field Permissions**: read and edit per field - **Tab Visibility**: Default On, Default Off or Hidden per tab - **Page Layouts**: the profile's page layout assignments, by record type - **Apex Classes**, **VF Pages** and **Custom Permissions** the persona can use - **Apps**: apps and connected apps the persona can access ![Persona Simulator results for the CGCloud_User_Profile_Non_Sales profile plus the Sales Agreements permission set: totals, result tabs and the object permissions table with sources](https://www.sfdcpolice.com/docs/shots/persona-simulator-2.png) *1 Totals for the persona. 2 Result tabs, here Object Permissions. 3 Filter box. 4 Sources column. 5 A permission set that adds to the profile (PS: Sales_Agreements).* Each permission shows a check (granted), a cross (muted) or a dash (not granted). A **Sources** column names the profile, permission set or group that grants it, so you can see where each permission comes from. #### Field-Level Access Pick the Field Permissions tab and filter the read (R) and edit (E) columns to spot fields the persona cannot read or edit. #### Save and Export - **Save Current** stores the persona (its profile and permission sets) in your browser, so you can load it again later. - Export the results to Excel, or copy the object, field or tab table as CSV. ### Use Cases - **Check a permission change** before you assign a new permission set - **Debug access issues** reported by a user: start from their profile, add their permission sets, and see what they add up to - **Audit a profile** before a release - **Plan a new hire's access**: try the profile and permission sets they will get before day one ## Compare (PS Comparison) Source: https://www.sfdcpolice.com/docs/features/ps-comparison > Put two permission sets side by side and see which object and field permissions differ, which objects only one of them covers, and export the diff as CSV. PS Comparison answers "what does this permission set grant that that one doesn't?" You pick two permission sets and see their object permissions next to each other, with the differences marked, and you can open any object to compare its field permissions. Open **Permissions → PS Comparison**. The page heading is **Permission Set Comparison**. In the release after 1.1.13 the sidebar entry is called **Compare** and has two tabs: **Permission sets & profiles** (this screen, which opens first, so old links behave as before) and **Users** (two users side by side, the same comparison as [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain) → Compare Users). The rest of this page describes the permission set screen as it works in 1.1.13. ### How to use it 1. Under **Side A**, pick a permission set from the list (**-- Select permission set --**). Each entry shows the label and the API name. 2. Under **Side B**, pick the second one. A permission set chosen on one side is greyed out on the other; if both sides end up the same, the page says **Please select two different permission sets to compare.** 3. Click **Compare**. It reads **Comparing...** while it loads. 4. Use the filter tabs to narrow the table: **All**, **Different**, **Only in** *Side A's label*, **Only in** *Side B's label*. Each tab shows its count. 5. Click an object row to open its field permissions. Click it again to close it. 6. Click **Export Diff as CSV** to download the comparison. ### What you see **Summary chips** above the table count the objects that are identical, different, only in Side A, and only in Side B. **The object table** has one row per object that either permission set has an object permission row for, sorted by API name. For each permission there are two columns, **A** and **B**: **Create**, **Read**, **Edit**, **Delete**, **View All Records**, **Modify All Records** and **View All Fields**. A granted permission shows **Y**, a missing one shows **-**, and cells that differ between the sides are highlighted. Objects that only one side covers carry an **Only A** or **Only B** badge. The **Different** tab lists objects both sides cover where at least one permission differs. Objects covered by only one side are counted under their own tabs, not under Different. **Field permissions.** When you open an object, a second table lists every field that either permission set has a field permission row for, with **Read** and **Edit** for each side. If neither has any, it says **No field permissions configured for either permission set on this object.** **The CSV** (`permission-diff-.csv`) has one line per object with true/false for each permission on each side and a Diff column (YES or NO). Fields are added only for the objects you opened before exporting. ### What it reads and writes - The permission set list: PermissionSet records that are not owned by a profile, ordered by label. - For each side: its ObjectPermissions rows. - When you open an object: the FieldPermissions rows for that object, for each side. It reads from the org you are connected to and changes nothing. It is a read-only view; to change a permission set, use [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor) or [Permission Builder](https://www.sfdcpolice.com/docs/features/permission-builder). ### Limits - **Profiles are not in the list.** Only permission sets that are not owned by a profile can be picked, so you can't compare a profile with a permission set here. - **View All Fields always shows "-" on both sides** in version 1.1.13: the object permission query does not read that permission, so the column can't show a grant. Check it in Salesforce Setup. Fixed in the release after 1.1.13. - **Field rows in the CSV are misaligned** in version 1.1.13: a field's Read and Edit values are written under the Create and Read columns of the header. Use the on-screen field table for field permissions. Fixed in the release after 1.1.13. - Results are cached: the permission set list for 15 minutes, and object and field permissions for 30 minutes. A change made in Setup during that time may not show yet. - An object with no object permission row on either side does not appear, even if a field on it has field permissions. - It compares two permission sets as stored. It does not show what a user gets from all their permission sets, groups and profile together; for that, see [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain) (called Permission Intelligence in 1.1.13). ### Related - [Permission sets vs profiles](https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles) - [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor) - [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain) ## Related Records Source: https://www.sfdcpolice.com/docs/features/related-records > Open a record and click through its parent lookups and child lists, without writing SOQL. For six real use cases with screenshots, read [Related Records: everything connected to a record](https://www.sfdcpolice.com/blog/guide-related-records). Related Records lets you move through your Salesforce data one record at a time and see how records connect across objects, without writing SOQL or opening multiple tabs. ### Features #### Record Explorer Open a record and see its parent lookups and the child lists that have records: - Parent relationships (lookup and master-detail) - Child relationships that have at least one record (lists with no records are hidden) - Polymorphic lookups, resolved to the right object A child list pages through up to 2,000 records (the Salesforce limit for SOQL OFFSET). #### Click Through Click a related record's Id to open it and see its own parents and children. A breadcrumb keeps your path (the starting record plus the last 9 steps). Child lists load their records when you open them. #### Record Preview Click elsewhere on a row in a child list and the side panel shows that row's fields, without leaving the current record. The panel also has **History** (field history) and **Cascade** tabs. #### Export **Export** downloads the current record's fields (API name, label, type and value) as **CSV** or **JSON**. #### Child lists that load as they're counted (from version 1.1.13) Related lists appear as soon as their counts arrive; the heading says "still counting…" until the last one, and you can open a list meanwhile. Lists are counted in groups (one query asks up to 20 relationships whether they have any records, then only the lists that do are counted), so a large account loads in about 2 seconds instead of 10 and uses far fewer API calls. A list is hidden only when Salesforce says it has no records. #### Readable names and a filter (from version 1.1.13) Each child list shows its object's label ("Job Lists", "Visits") with the relationship API name beside it; hover for the object and lookup field. With more than five lists, **Filter related lists** narrows them by label, API name or object. #### Copy SOQL / Open in SOQL Builder (from version 1.1.13) An open list has **Copy SOQL** and **Open in SOQL Builder**. Both use the list's own query (same fields, the parent filter and the date chip you picked, same order) without the page's 10-row limit, so SOQL Builder runs it over all records. #### Formula fields (from version 1.1.13) Hyperlink and image formula fields show as a link or as text, never as raw HTML. Only http(s) and relative links become links. ### Use Cases - **Data investigation** — quickly trace data from a case back to the account - **Impact analysis** — see the child records a parent's delete would cascade to directly (one level) - **Documentation** — map out complex data models for new team members - **Migration prep** — understand record dependencies before migrating data ## REST API Explorer Source: https://www.sfdcpolice.com/docs/features/rest-api-explorer > Build, test, and inspect Salesforce REST API calls directly from your browser. The REST API Explorer lets you make authenticated Salesforce REST API calls without setting up Postman, configuring OAuth, or writing code. It uses your existing browser session. ### Features #### Request Builder Construct any REST API request: - **Method** — GET, POST, PATCH, PUT, DELETE - **Endpoint** — Relative path (e.g., `/services/data/v60.0/sobjects/Account`), or a full URL on your org's own host. Other hosts are refused. - **Headers** — Custom headers with key-value editor - **Body** — a plain text box for the JSON body (POST, PATCH and PUT) #### Common Endpoints Quick-access buttons for the most-used endpoints: - `/sobjects` — List all objects - `/sobjects/{ObjectName}/describe` — Full schema for an object - `/query?q=...` — Execute SOQL - `/tooling/...` — Tooling API endpoints - `/composite/...` — Composite operations #### Response Viewer The response panel shows: - Status code and response time - Response body (pretty-printed JSON) - Response headers - Request history (last 20 calls, kept until you reload the page) #### Saved Requests Save frequently used requests with a name and load them again later. Saved requests stay in your browser. #### Authentication No setup needed. The extension uses your current Salesforce session token, so each request runs as you, with your permissions. ### Common Use Cases - Test a custom REST endpoint before integrating with an app - Inspect the describe response for a custom object - Debug a SOQL query issue by running it through the API - Explore Tooling API for metadata operations - Test composite API operations ## Security Insights Source: https://www.sfdcpolice.com/docs/features/security-insights > Your org's security posture in one place: a score across six dimensions, risky permission combinations, per-user blast radius, connected apps and field checks. Security Insights turns the question "is our org secure?" into a dashboard you can read. It reads the permission sets, permission set groups and profiles assigned to active users, and shows the accounts and combinations that put the org at risk, with the user and their permission sets attached so you can act. It reads at most **2,000 permission set assignments** of active users. In a larger org, assignments past that limit are not read, so some users may be missed, and the page does not warn you. *Top screenshot: 1 The posture score. 2 The six-dimension chart. 3 One dimension's score and reason. 4 Blast Radius tab. 5 Toxic Combos tab. 6 Integrations tab (connected apps).* ### Posture score The **Score** tab shows one posture score from 0 to 100 with an A to F grade. It is a weighted average of six dimensions: - **Permission Hygiene**: how many active users hold more than 10 permission sets. - **Least Privilege**: how many active users have Modify All Data or View All Data. - **Access Cleanup**: how many permission sets are assigned to no active user. - **Login Security**: the share of failed logins in the last 30 days. - **Integration Risk**: stale or unused OAuth tokens compared with your connected apps. - **Audit Readiness**: how many setup changes were made in the last 7 days. If a dimension cannot be read (for example, your user cannot query login history), it scores 50 and says it could not be assessed. Use the score to find the findings below, not as an audit result on its own. ### God mode Security Insights flags a user as **God Mode** when they hold **Modify All Data**, **View All Data** and **Manage Users** together. Permissions are combined across the profile and every assigned permission set, so a user who gets each one from a different place is still flagged. The **Least Privilege** dimension separately counts users with Modify All Data or View All Data. For background on why this matters, see [How to find every god-mode user in your org](https://www.sfdcpolice.com/blog/find-god-mode-users). ### Toxic combinations Some permissions are dangerous only together. The **Toxic Combos** tab checks these: - **God Mode** (critical): Modify All Data + View All Data + Manage Users. - **Admin Takeover** (critical): Manage Users + Author Apex. Create admin users and deploy code. - **Data Exfiltration Risk** (high): View All Data + Run Reports. See everything, then export it in reports. - **Modify + Customize** (high): Modify All Data + Customize Application. Change both data and configuration. - **Password Bypass** (high): Password Never Expires + Modify All Data. Skipped if the org does not expose that permission. - **Inactive God** (medium): no login in the last 90 days (or never), but still holds Modify All Data or View All Data. - **Permission Stacking** (medium): more than 10 permission sets. - **External Overprivilege** (medium): an external or community user with Modify All Data, View All Data or Manage Users. Each finding lists the affected users, their permission sets and suggested fixes. ![Security Insights Toxic Combos tab: six of eight combinations detected, with the permissions in each](https://www.sfdcpolice.com/docs/shots/security-insights-2.png) *1 Toxic Combos tab. 2 Summary of combinations detected and users affected. 3 Severity of a combination. 4 The permissions that make it toxic. 5 Link to the affected users and remediation. 6 A combination with no users shows Clear. 7 Re-scan.* ### Blast radius Search for one user to see their **blast radius**: every object they can reach, with create, read, edit, delete, View All and Modify All, and the permission set that grants each one. It counts objects, not records. Here a user is marked **God Mode** if any of their permission sets or their profile has Modify All Data, a looser rule than the Toxic Combos check above. ![Security Insights Blast Radius for Steve Rep: the profile and permission sets that give access, and the objects they reach](https://www.sfdcpolice.com/docs/shots/security-insights-3.png) *1 User search. 2 One-line summary of what the user reaches. 3 The user. 4 The profile and permission sets that give access. 5 The objects reached, here with Modify All.* ### Check one user In the release after 1.1.13, each row of the **Users** tab has a **Check** button (and **Check a user** finds anyone else). It opens a panel with that user's health check, risky permission combinations and suggested fixes, plus a link to their Blast Radius. A fix asks you to confirm first and is never applied on its own. It replaces the **Assistant** tab of version 1.1.13 and the Audit User mode of [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain). ### Where findings come from The blast radius names the permission set or profile that grants each object. Toxic combination findings list all of a user's permission sets; they do not say which one grants the risky permission, so check those permission sets to find it. ### Beyond permissions Security Insights also reviews **connected apps** (OAuth tokens and third-party access into the org) and has **field-level analytics**: field-level security coverage per object, and editable fields that no permission set or profile has field-level security for. ### Related reading - [Explain Access](https://www.sfdcpolice.com/docs/features/permission-chain): trace a user's object or field access to its source. - [Persona Simulator](https://www.sfdcpolice.com/docs/features/persona-simulator): preview the access a profile and permission sets give, before and after a change. - [Org Health](https://www.sfdcpolice.com/docs/features/org-health): broader org checkups, including permission debt. ## Smart Data Generator Source: https://www.sfdcpolice.com/docs/features/smart-data-generator > Fill an empty sandbox with realistic, schema-aware test data: relationships and picklists respected, active validation rules flagged. A fresh developer sandbox has no data, and building 50 related records by hand to test a flow is an afternoon you will not get back. Smart Data Generator creates realistic test data that respects your schema, so you can populate an org in minutes instead of hours. ### Zero configuration Point it at an object and it reads the object's describe metadata to learn the rules before generating anything: - **Required fields** are filled. A required lookup needs its parent object in the run, or existing parent records in the org; otherwise preview and insert are blocked and a warning names the missing lookup. Salesforce can still reject a record for other reasons, and those show in the error log. - **Relationships** are resolved in order — parents are created before the children that reference them. - **Active validation rules** are listed as warnings for each object, so you can adjust values before you generate. Generated values are not changed to satisfy them. - **Picklists** (including dependent picklists) draw from the actual allowed values. ### Realistic values Generated data looks like real data, not `Test 1`, `Test 2`. Names, addresses, dates, and currency values are believable, and naming is **object-aware**: - `Account.Name` becomes a company name. - `Opportunity.Name` becomes something like "Acme - Q4 Renewal". - `Product2.Name` becomes a product name. - `Case.Subject` becomes a realistic case subject. - `Task.Subject` becomes a realistic task line. Custom objects fall back to sensible generic names. ### Wave-by-wave insertion Records insert in waves using sObject Collections at 200 records per batch, in dependency order, so a parent object and its children land in the right sequence. A live execution panel shows progress per wave, and you can cancel mid-run. Cancel stops before the next 200-record call; a call already sent still finishes, and its records stay in the rollback ledger. ### Safe by default Smart Data Generator is built not to waste your API quota or corrupt data: - It **halts on fatal errors** — an expired session, a request-limit breach, or a maintenance window stops the run instead of retrying into the ceiling. - Transient failures retry with backoff; permanent ones surface row-by-row in the error log. - A **rollback ledger** records everything inserted, so a generation run can be undone — even a run that halted partway. ### Typical workflow 1. Select the object (and any related objects) you want to populate. 2. Choose how many records per object. 3. Review the API-call estimate. 4. Generate — and watch the waves insert. 5. Keep the data, or roll the whole run back from the ledger. ### When a link isn't set Lookups between generated records (for example Parent Account in a hierarchy) are set in a second pass after the insert, because a record can only point at its parent once the parent exists. If Salesforce rejects one of those links, for example a validation rule, the record stays inserted and only the link is left blank. The **Needs linking** tab lists each record. From version 1.1.13 it also shows Salesforce's reason for each one; before that, **Copy errors** copies the reasons to your clipboard. If the link points at a record that failed to insert, fix and retry that record and the link is set automatically. ### Walkthrough [Moving and making test data](https://www.sfdcpolice.com/blog/guide-data-migrator-and-generator) follows a real run step by step: 5 accounts and 10 contacts generated in a Consumer Goods org, the 3 links a validation rule refused, and **Undo all**. ### Related reading - Object Data Dictionary (in the extension's Metadata menu) — inspect the fields of the object you are generating. - [SOQL Builder](https://www.sfdcpolice.com/docs/features/soql-builder) — query and verify the generated records. ## SOQL Builder Source: https://www.sfdcpolice.com/docs/features/soql-builder > Build, run, and export SOQL queries visually — no syntax memorization required. The SOQL Builder gives you a visual interface to construct and run SOQL queries against any Salesforce org. No need to memorize syntax or guess field names. ### Features #### Visual Query Builder Select your object, pick fields from a dropdown, add WHERE clauses, set ORDER BY and LIMIT — the SOQL text updates as you build. - Select from all standard and custom objects - Checkbox field picker with search - Visual WHERE clause builder (field, operator, value) - ORDER BY with ASC/DESC toggle - LIMIT box (up to 50,000) with quick picks from 10 to 2,000 #### Query Editor Switch to the SOQL editor at any time to fine-tune your query or paste an existing one. - Syntax highlighting for SOQL keywords - Field name autocomplete - Salesforce's error message shown when a query fails - The error underlined in the query, with plain-word fixes (from version 1.1.13) - Query history (last 50 queries) #### Results Table Results are displayed in a sortable, filterable table. You can: - Sort any column ascending or descending - Filter rows by keyword - Click any record ID to open it in Salesforce - Expand relationship fields #### Export Options Export your results in multiple formats: - **CSV** — comma-separated for Excel/Sheets - **Excel** — a `.xlsx` file - **Copy to clipboard** — as CSV, or as tab-separated text that pastes into Excel ### Access SOQL Builder — like every other module — is fully unlocked and free. No subscription, no trial, no account required. ### Example Queries ```sql -- Find all active users SELECT Id, Name, Email, Profile.Name FROM User WHERE IsActive = true ORDER BY Name ASC LIMIT 50 -- Custom object with relationship query SELECT Id, Name, Account.Name, CreatedDate FROM Contact WHERE Account.Type = 'Customer' ORDER BY CreatedDate DESC LIMIT 100 ``` ## Unused Metadata Source: https://www.sfdcpolice.com/docs/features/unused-metadata > List Apex, custom fields, inactive validation rules and flows, and unassigned permission sets that may be unused, so you can review them for cleanup. Unused Metadata lists metadata that may no longer be used, so you can review it before a cleanup. It covers Apex classes and triggers, custom fields, inactive validation rules, inactive flows and unassigned permission sets. Open **Metadata → Unused Metadata**. The page is titled **Unused Metadata Finder**. The results are candidates to review, not a list of things that are safe to delete. ### How to use it 1. Pick a type: **Apex Classes**, **Apex Triggers**, **Custom Fields**, **Inactive Validation Rules**, **Inactive Flows** or **Unassigned Permission Sets**. 2. For **Custom Fields**, choose the object in **Pick an object...**. 3. Click **Find unused**. 4. To keep the list, click **Export CSV**. The file has the columns Type, Name, Id and LastModified. 5. Click the link icon on a row to open the item in Salesforce Setup. ### What you see The results table has the item's name and its **Last modified** date. Above it, the page shows **Candidates**. For Apex and custom fields it also shows **Referenced** and **Total scanned**. How each type is found: - **Apex Classes, Apex Triggers, Custom Fields**: items with no recorded reference in Salesforce's dependency data (`MetadataComponentDependency`). The table is titled **Likely unused**. Apex classes and triggers whose names look like test classes (for example ending in `Test` or `Tests`) are moved to a separate **Likely test classes** table, since tests normally have no callers. - **Inactive Validation Rules**: validation rules that are not active. The page notes they may be kept on purpose. - **Inactive Flows**: flows with no active version, which includes drafts and deactivated flows. - **Unassigned Permission Sets**: permission sets with no direct assignment to a user. In version 1.1.13 this includes sets that users get through a permission set group, so check each one's groups before you delete it: deleting a group member breaks the group. In the release after 1.1.13, group members count as in use and are not listed. For the dependency-based types, a note above the table says the data caps at 2,000 rows and does not track every reference (reports, managed packages, dynamic SOQL). If a scan reaches the cap, the note adds that you should treat the results as partial. ### What it reads and writes Unused Metadata only reads. It runs these queries through your current Salesforce session: - Tooling API: `ApexClass`, `ApexTrigger` and `CustomField` (only items outside any managed package namespace), plus `MetadataComponentDependency` for the referenced set. - Tooling API: `ValidationRule` where it is not active, and `FlowDefinition` with no active version. - Tooling API: `PermissionSet`, leaving out profile-owned permission sets, permission set groups and managed ones; and a regular SOQL query on `PermissionSetAssignment` to find which have assignments. It does not delete or change anything. Removing metadata is up to you, in Setup or your deployment tool. ### Limits - Every list is read with a limit of 2,000 rows. For Apex and custom fields, the referenced set is read for the whole org (for custom fields, at most 2,000 references across all objects), and only that cap triggers the "partial" warning. - Apex classes, triggers and custom fields from managed packages are left out. - References the dependency data doesn't track, such as reports, dynamic SOQL or a field name built in code, make a used item look unused. Check Setup's **Where is this used?** and ask integration owners before you delete. - Test classes are detected by name only. A test class with an unusual name stays in the main list. - In version 1.1.13, unassigned permission sets are checked against direct assignments only (see above). ### Related - [How do I find where a field is used?](https://www.sfdcpolice.com/docs/answers/find-where-a-field-is-used) - [Where Used](https://www.sfdcpolice.com/docs/features/where-used) - [Metadata Peek](https://www.sfdcpolice.com/docs/features/metadata-peek) ## Where Used Source: https://www.sfdcpolice.com/docs/features/where-used > Search an Apex class, trigger or custom field and see what references it and what it references, then click through the dependency chain. Where Used shows the metadata dependencies of one component: what references it, and what it references. You start from an Apex class, an Apex trigger or a custom field, and click any item in the results to explore that item in turn. Open **Metadata → Where Used**. The page is titled **Where Used Explorer**. ### How to use it 1. Type at least two characters in the search box (**Search an Apex class, trigger, or custom field…**) and click **Search**. For a custom field, type part of its API name without `__c`. The search matches field developer names, which don't include the suffix. 2. If the list is long, narrow it with the **Filter N results…** box. It filters by name or type without asking Salesforce again. 3. Click a result. The page loads its dependencies. 4. Click any item under **Used by** or **Uses** to explore that item. A breadcrumb above the results keeps your path; click an earlier entry to go back to it. 5. Click the link icon next to an item to open it in Salesforce Setup. The icon is hidden for types the extension can't link to. 6. Click **New search** to start over. ### What you see For the selected component, three numbers sit at the top: **Referenced by**, **References** and **Component** (its metadata type). Below them are two columns: - **Used by**: components that reference the selected one. - **Uses**: components the selected one references. In the release after 1.1.13, when **Used by** or **Uses** reaches 2,000 records, the page says the list may be incomplete and shows that count as "2000+". Each column groups items by type: **Apex**, **Flows & Workflow**, **UI & Layouts**, **Fields & Objects**, **Reports & List Views**, **Validation & Rules**, **Security** and **Other**. Each item shows its metadata type and name. If Salesforce has no dependency records for the component, the page says **No tracked dependencies** and reminds you that Salesforce doesn't record dependencies for every type, so an empty result doesn't always mean the component is safe to delete. Where Used does not tell you whether a flow or class reads or writes a field. For that, use the **Automations** link on the field hover tooltip, described in [How do I find where a field is used?](https://www.sfdcpolice.com/docs/answers/find-where-a-field-is-used). ### What it reads and writes Where Used only reads. It sends Tooling API queries through your current Salesforce session: - The search queries the `ApexClass`, `ApexTrigger` and `CustomField` Tooling objects by name. - Picking a component queries `MetadataComponentDependency` twice: once for rows where the component is the referenced item (**Used by**) and once for rows where it is the referencing item (**Uses**). It does not change anything in your org. ### Limits - In version 1.1.13, if Salesforce refuses one of the searches (for example because you can't read Apex), the page says nothing matched instead of showing the error. In the release after 1.1.13 it names the search that failed. - Search finds only Apex classes, Apex triggers and custom fields. Other types, such as flows, layouts and validation rules, appear once you reach them through the results. - Salesforce returns at most 2,000 dependency records per list, and each search returns at most 2,000 matches. In version 1.1.13 the page doesn't warn you when a list reaches 2,000, so a count of exactly 2,000 may be incomplete. In the release after 1.1.13, when **Used by** or **Uses** reaches 2,000 the page says the list may be incomplete and shows the count as "2000+". A search that returns 2,000 matches says to type more of the name. In the release after 1.1.13, the SOQL Builder's Where Used dialog does the same. - `MetadataComponentDependency` doesn't cover every kind of reference. As the page itself says, report-only and managed-package usage may be missing. For reports, use **Where is this used?** on the field in Setup. - Standard fields aren't in the search, because the search uses the `CustomField` object. ### Related - [How do I find where a field is used?](https://www.sfdcpolice.com/docs/answers/find-where-a-field-is-used) - [Unused Metadata](https://www.sfdcpolice.com/docs/features/unused-metadata) - [Metadata Peek and field hover tooltips](https://www.sfdcpolice.com/docs/features/metadata-peek) ## XML Builder Source: https://www.sfdcpolice.com/docs/features/xml-builder > Fill in a form to build Salesforce metadata XML for 35 types, download it or a package.xml and .zip, and validate or deploy the bundle to your org. XML Builder writes Salesforce metadata XML from a form, so you don't have to type the XML by hand. You can copy or download the file, collect several components into a bundle with a `package.xml`, and validate or deploy that bundle to the org you are connected to. Open **Metadata → XML Builder**. The page is titled **Metadata XML Builder**. ### How to use it 1. Under **Select Metadata Type**, pick a type. There are 35, including **Custom Field**, **Custom Object**, **Permission Set**, **Validation Rule**, **Custom Label**, **Record Type**, **Named Credential**, **Workflow Rule** and **Profile**. 2. For types that belong to an object (fields, validation rules, record types, list views, workflow items and others), pick the object first. 3. To start from something that already exists, use the loader above the form (for example **Load Existing Field**) and pick an item. Its values fill the form. Use the **New** button next to it (for example **New Field**) to start blank. 4. Fill in the form. The XML preview on the right updates as you type, along with the file's SFDX path. 5. Use the toolbar: **Copy XML**, **Download**, **Copy Path** (the SFDX file path), **Import** (paste existing XML to load it into the form) or **Reset** (asks you to confirm). Copy, download and add-to-bundle stay disabled while a required field is missing or a value is invalid. 6. To build a deployment, click **Add to bundle**. Repeat for other components. The bundle bar at the bottom shows **Bundle (N)** and lets you download **package.xml** or **Download .zip**, or click **Deploy to org**. When the extension can read your org's metadata types, the type page also says how many types your org exposes, and lists **Other types in your org**. Picking one of those opens a read-only view: choose a component to see its XML, then **Copy** or **Download** it. ### Deploying **Deploy to org** opens a dialog for the connected org: - **Validate only (check-only — nothing is saved)** is ticked by default. With it ticked, the button says **Validate**; untick it and the button says **Deploy**. - **Test level**: **No tests (sandbox only)**, **Run local tests** or **Run all tests in org**. Nothing is sent until you click **Validate** or **Deploy**. The dialog then shows progress, the number of components and tests, and lists **Component failures** and **Test failures**. You can close it with **Close (deploy continues)**; the deployment keeps running in Salesforce. A **Deployment status in Setup** link opens Setup's Deployment Status page. ### What it reads and writes Reads, through your current session: - The Metadata API's describe, to list the metadata types your org exposes. - Existing components for the loaders, mostly through Tooling API queries (for example the `Metadata` field of `CustomField`) and object describes. Writes: only when you click **Deploy** with **Validate only** unticked. The bundle is sent as a `.zip` to the Metadata API (`deployRequest`) with "roll back on error" turned on, so Salesforce saves either all components or none. A validation runs the same checks without saving. Copying, downloading and building the bundle don't touch the org. ### Limits - In version 1.1.13, if the deploy's status can't be read after Salesforce has accepted it (for example a network blip, or the 10-minute polling limit), the dialog says **Deploy failed to start** even though the deploy may be running or finished. Check Deployment Status in Setup before you deploy again. In the release after 1.1.13 the dialog says the deploy started and its status couldn't be read. - Only the 35 listed types have a form. Other types can only be viewed and copied as XML, not edited or added to a bundle. - Many loaders and the read-only viewer list at most 200 existing items, and the viewer doesn't say when it hit that number. - The bundle is kept in the page's memory. Copy or download what you need before you close the tab. - The dialog checks the deployment every 2.5 seconds for up to about 10 minutes. After that it tells you to check Deployment Status in Setup. - The **API v** box on the bundle bar sets the API version for `package.xml` and the deploy. It is the same API version setting the rest of the extension uses. - **Matching Rule** XML can be built and downloaded, but **Add to bundle** stays disabled for it in this version. ### Related - [Metadata Peek](https://www.sfdcpolice.com/docs/features/metadata-peek) - [Why Change Sets Fail, and How to Move the Records They Can't](https://www.sfdcpolice.com/blog/why-change-sets-fail) ## Guides Source: https://www.sfdcpolice.com/docs/guides > Concept walkthroughs and playbooks for Salesforce permission and data management. ### Guides Guides are deeper than feature documentation — they walk through concepts, workflows, and best practices for working with Salesforce permissions, data, and org administration. #### Concept Walkthroughs Understand how Salesforce controls access and manages data: - [The 10 Layers of Record Access](https://www.sfdcpolice.com/docs/guides/record-access-layers) — How Salesforce evaluates permission at each step, from object-level down to field-level visibility - [Permission Dependencies](https://www.sfdcpolice.com/docs/guides/permission-dependencies): which permissions need others, what a removal takes with it, and how muting reverses the chain - [Permission Sets vs Profiles](https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles) — When to use each, and how to structure them for maintainability - [Migrating Orgs Safely](https://www.sfdcpolice.com/docs/guides/migrating-orgs-safely) — A playbook for moving data between orgs without data loss Start with record access layers if you're troubleshooting "why can't this user see this field?" Start with permission sets vs profiles if you're redesigning your permission model. ## Migrating Orgs Safely Source: https://www.sfdcpolice.com/docs/guides/migrating-orgs-safely > A practical playbook for moving data and configuration between Salesforce orgs without losing records or sleep. Moving data and configuration between orgs is where careful admins get burned. The failure modes are well known — broken references, silent overwrites, no way back — and all of them are avoidable with a disciplined sequence. This is that sequence. ### 1. Pick the right strategy Not every migration is the same, and the right approach depends on the relationship between the orgs: - **Sandbox seed.** Populating a sandbox from production. The orgs are related and share record IDs, so matching is direct. You usually want a report-only default so you do not clobber existing sandbox data. - **Promote.** Pushing changes forward through related environments. Auto-patching drift is appropriate here. - **Unrelated orgs.** Two productions that do not share IDs. You cannot match on Id; you need an external ID or a composite natural key. Naming the strategy up front decides everything downstream — matching, drift handling, and rollback posture. ### 2. Map objects and dependencies List the objects, then order them by dependency: parents before children. A migration that loads child records before their parents fails on missing references. Let the tooling resolve the order from the relationship metadata rather than building the list by hand — and remember that required lookups are non-nillable but are *not* Master-Detail; classify by `relationshipOrder`, not by whether the field is required. ### 3. Always dry-run first Never let the first write be a surprise. A dry run shows exactly what will be created, updated, or skipped, and buckets records by how they compare to the target: - **identical** — leave alone - **drifted** — exists but differs - **missing** — needs creating - **ambiguous** — matches more than one target; do not guess, filter it out Read the dry run before you write. It is the single highest-leverage habit in org migration. ### 4. Match records deliberately When orgs share IDs, matching is automatic. When they do not, choose your key explicitly: a true **external ID** field if you have one, or a **composite natural key** (for example, account name plus billing country) when you do not. A wrong key is worse than no migration — it merges records that should be distinct. ### 5. Keep rollback available Inserts are easy to undo. Updates are not — unless you captured the target's **before-state** first. Insist on a migration path that snapshots prior values and can PATCH them back, so an update is reversible field-for-field, not just "delete what I created." Treat any migration that cannot reverse an update as a one-way door. ### 6. Verify after the write A run that reports success is not the same as a correct migration. Verify: - **record counts** match expectations per object - **relationship integrity** holds — sample child records and confirm their parents resolved - **picklist and required-field** values are valid in the target ### How Data Migrator implements this Each step above maps to a built-in safeguard in [Data Migrator](https://www.sfdcpolice.com/docs/features/data-migrator): related/unrelated detection, automatic dependency ordering, a mandatory dry run with a conflict forecast, drift reporting for records that already exist in the target, external-ID and composite-key matching, before-state rollback snapshots (from version 1.1.13, a lookup patched after the main load is applied only once its original value is snapshotted), and post-load verification with relationship-integrity sampling. The discipline is the point; the tool just makes it the default. ### Related reading - [Why Change Sets fail](https://www.sfdcpolice.com/blog/why-change-sets-fail) - [Data Migrator reference](https://www.sfdcpolice.com/docs/features/data-migrator) ## Permission Dependencies Source: https://www.sfdcpolice.com/docs/guides/permission-dependencies > Which Salesforce permissions need others: what a grant must include, what a removal takes with it, and how muting reverses the chain. ### Permission dependencies Salesforce won't save some permissions without others. Edit needs Read, Delete needs Edit, and Modify All needs View All, Delete and Edit. This guide lists those rules. When you save a profile or permission set in Setup, Salesforce turns on what your change needs for you. Changes made through the API are not fixed for you: a change that breaks a rule is refused. Salesforce's help says that for API updates "you must manually fix broken permission dependencies". Tools that write permissions through the API, including SFDC Police, have to follow these rules themselves. The object and field rules below were checked against a live org in November 2026. The quoted messages are the errors Salesforce returned. #### Object permissions | To grant | You also need | What Salesforce says otherwise | |---|---|---| | Read | Nothing | | | Create | Read | "Permission Create Lead depends on permission(s): Read Lead" | | Edit | Read | "Permission Edit Lead depends on permission(s): Read Lead" | | Delete | Edit, and so Read | "Permission Delete Lead depends on permission(s): Edit Lead" | | View All Records | Read | "Permission View All Lead depends on permission(s): Read Lead" | | Modify All Records | View All Records, Delete and Edit, and so Read | "Permission Modify All Lead depends on permission(s): View All Lead", and without Edit and Delete: "…depends on permission(s): Delete Lead; … Edit Lead" | | View All Fields | Read | Salesforce Help: the user "must also have at least Read permission" | Removing a permission takes away everything that needs it: | To remove | Also remove | |---|---| | Read | Create, Edit, Delete, View All, Modify All, View All Fields | | Edit | Delete, Modify All | | Delete | Modify All | | View All Records | Modify All | #### Field permissions Field Edit needs field Read. Granting Edit without Read is refused with "Read permission is required for: Lead.Industry". Removing Read also removes Edit. #### Muting permission sets A muting permission set removes permissions from its own permission set group, so the chain runs the other way. To mute a permission, first mute everything that depends on it. Muting Delete before Modify All is refused with "To mute Delete, first mute Modify All Records." #### Master-detail objects A child object's permissions need permissions on its parent (Salesforce Help, *Object Permissions*): | If the child object has | The parent object needs | |---|---| | Modify All Records or View All Records | View All Records | | View All Records or Read | Read | #### Everything else: your org's own list Many more dependencies exist between system permissions and objects. For example, Export Reports needs Run Reports, Mass Email needs Send Email, Import Personal Contacts needs Create on Account, and Modify All Data needs View All Data, View Setup and permissions on many objects. Which rules apply depends on your org's edition, features and installed packages. Salesforce lists them in the `PermissionDependency` object of the Tooling API. One org we checked had more than 2,000 rows. To see what a permission needs in your org, run this with the Tooling API, for example in SFDC Police's SOQL Builder with its Tooling API toggle on: ```sql SELECT Permission, PermissionType, RequiredPermission, RequiredPermissionType FROM PermissionDependency WHERE Permission = 'ExportReport' ``` Object entries look like `Account`. The permission names are `read`, `create`, `update` (Edit), `delete`, `viewAllRecords` and `modifyAllRecords`. #### Sources - Salesforce Help: [Object Permissions](https://help.salesforce.com/s/articleView?id=platform.users_profiles_object_perms.htm&type=5) - Salesforce Help: [Permission Dependencies and Alignment](https://help.salesforce.com/s/articleView?id=platform.users_perm_dependencies.htm&type=5) #### Related - [The 10 Layers of Record Access](https://www.sfdcpolice.com/docs/guides/record-access-layers) - [Permission Matrix](https://www.sfdcpolice.com/docs/features/data-dictionary) - [Access Editor](https://www.sfdcpolice.com/docs/features/access-editor) ## Permission Sets vs Profiles Source: https://www.sfdcpolice.com/docs/guides/permission-sets-vs-profiles > When to use a profile, a permission set, a permission set group, or a muting set — and how to migrate from profile-based permissions. Salesforce gives you four tools for granting permissions, and they are not interchangeable. Using the right one keeps your security model legible; using the wrong one creates the tangle most orgs are stuck in. Here is how they fit together and how to move toward the model Salesforce is steering everyone toward. ### The four building blocks **Profiles.** Every user has exactly one profile. Think of it as the baseline — the floor of what a user can do. Historically, admins piled object permissions, field permissions, and system permissions onto profiles. That is the pattern Salesforce is now moving away from. **Permission sets.** Stackable add-ons. A user can have many, and each grants additional access on top of the profile. Because they are additive and reusable, they are the right place for feature- or function-based access: a `Run Reports` set, a `Manage Campaigns` set, a `Knowledge Author` set. **Permission set groups.** A bundle of permission sets assigned as one unit, usually mapped to a job function — "Sales Rep" might be a group containing several permission sets. Assigning the group assigns everything in it. **Muting permission sets.** A subtraction, used inside a group. If a group grants more than a particular role should have, a muting set removes specific permissions for that group without forking the underlying sets. ### When to use which - Put the **shared baseline** every user of a type needs on the **profile** — login hours, default record types, the bare minimum. - Put **feature- and function-based access** in **permission sets**, named for what they enable. - Bundle the sets for a **job function** into a **permission set group**. - Use a **muting permission set** to trim a group for a specific case, rather than creating a near-duplicate set. The goal is that someone can read a user's access by reading the *names* of their assignments — `Sales Rep` group, plus a `Forecast Manager` set — instead of spelunking through a 200-line profile. ### Why Salesforce is moving away from profile permissions Profiles are rigid: one per user, hard to reuse, and hard to audit. Permission sets are composable and reusable, which makes access easier to reason about and change. Salesforce has signaled for years that permission-set-based administration is the direction of travel, and newer features assume it. ### A migration approach Moving from fat profiles to permission sets is a project, but a tractable one: 1. **Inventory** what each profile actually grants today. (Permission Builder's comparison view makes the diff readable.) 2. **Group by job function**, not by person. Identify the real roles in your org. 3. **Build feature-based permission sets** — small, named, single-purpose — and assemble them into groups per function. 4. **Validate effective access** before you cut over. This is the step people skip and regret. 5. **Cut over** one function at a time: assign the new group, confirm parity, then thin the profile. ### Validate before you cut over The risk in any permission migration is silently removing access someone needs. Use [Persona Simulator](https://www.sfdcpolice.com/docs/features/persona-simulator) to preview a user's full effective access — Profile + permission set groups + direct permission sets + muting — *before and after* the change, so you confirm parity rather than discover a gap in production. Use [Permission Builder](https://www.sfdcpolice.com/docs/features/permission-builder) to construct the sets with dependency awareness so you do not grant a child permission without its parent. ### Related reading - [Profiles are fading: a practical move to permission sets](https://www.sfdcpolice.com/blog/profiles-to-permission-sets) - [The 10 layers of record access](https://www.sfdcpolice.com/docs/guides/record-access-layers) ## The 10 Layers of Record Access Source: https://www.sfdcpolice.com/docs/guides/record-access-layers > How Salesforce evaluates record access through ten distinct layers, from objects to fields. ### The 10 Layers of Record Access Record access in Salesforce is evaluated as a series of ten distinct layers. A user must pass through all layers to view, edit, or delete a record. Understanding each layer helps you diagnose permission issues quickly. #### Layer 1: Object Permissions Before a user can access a record of any type, they need object-level CRUD (Create, Read, Update, Delete) permissions. These come from their assigned profile or permission sets. - **Read** permission grants viewing rights to all records of that object type - **Create** allows creating new records - **Update** allows editing existing records - **Delete** allows deleting records The View All and Modify All checkboxes bypass all lower layers for that object — users with these checked get access to every record, regardless of ownership or sharing rules. #### Layer 2: Org-Wide Defaults Org-Wide Defaults set the baseline sharing model for each object: Private, Public Read Only, or Public Read/Write. If an object is set to Private, users can only see records they own or that are explicitly shared with them. If it's Public Read/Write, all users with Read/Update permissions can see and edit all records (assuming no other layers block them). #### Layer 3: Ownership In a Private org-wide default, record ownership determines access. The record owner and users above them in the role hierarchy can see and edit the record. Users below them in the hierarchy cannot, unless the record is shared with them via Layer 5 (sharing rules) or Layer 7 (manual shares). #### Layer 4: Role Hierarchy The role hierarchy creates a permission "flow" — users in parent roles can see and edit records owned by users in child roles (if the org-wide default and object permissions allow it). If a user's role is above the owner's role in the hierarchy, they inherit access. If below, they do not. #### Layer 5: Sharing Rules Sharing rules automatically grant access based on criteria (owner-based or criteria-based). An owner-based sharing rule says "if the record owner is in group X, also grant access to group Y." A criteria-based sharing rule says "if the record meets condition Z (e.g., Stage = Closed), grant access to group Y." Sharing rules work at the object level and grant either Read-only or Read/Write access. They apply to all records matching the rule, automatically. #### Layer 6: Territory Management Territory management (if enabled) assigns records to territories, and territories to users. Users assigned to a territory can see all records assigned to that territory. Territory hierarchies also allow users to see records in child territories, similar to role hierarchy. #### Layer 7: Teams Teams (Account Teams, Opportunity Teams, and Case Teams) allow explicit, record-level sharing without formal sharing rules. The record owner adds team members directly to a specific record. Teams can grant Read or Read/Write access. #### Layer 8: Manual Shares Manual shares let the record owner (or admins) explicitly share a single record with a user or group. This is the "most granular" layer — one user gets access to one record. Manual shares can be Read-only or Read/Write. #### Layer 9: Implicit Parent-Child Sharing If a user has access to a parent record, they implicitly see child records (e.g., Contacts owned by a shared Account). This is automatic — you don't set it up, but it applies whenever a child field is a master-detail relationship. #### Layer 10: System Permissions System permissions like View All Data and Modify All Data override all other layers. A user with View All Data can see every record in the org, regardless of object permissions, org-wide defaults, ownership, sharing, or anything else. Modify All Data does the same for updates and deletes. --- ### After Record Access: Field-Level Security & Layout Control Even if a user passes all ten record access layers, two more gates apply: **Field-Level Security (FLS)** — Applied per field within the object. If a user lacks Read permission on a field, they cannot see it even if they can see the record. If they lack Edit permission, they cannot modify it. **Page Layout & Lightning Page Assignment** — A user's assigned page layout determines which fields, sections, and buttons appear when they view a record. A field not on their page layout is hidden from their view, even if they have FLS Read permission. Similarly, Lightning Page assignments determine which components they see. **Record Type Assignment** — A user's record type assignment limits which record types they can create or access. If a user is not assigned a record type, they cannot work with records of that type. --- ### How Access X-Ray Maps the Layers Access X-Ray in the SFDC Police floating panel checks one record for one user, layer by layer: 1. **Object permissions** — CRUD from the profile, permission sets and permission set groups 2. **Org-wide default** — internal and external sharing for the object 3. **Ownership** — who owns the record 4. **Role hierarchy** — whether the user's role is above the owner's 5. **Sharing rules** — and the other shares that reach the record 6. **System bypass permissions** — View All / Modify All 7. **Record access verdict** — Salesforce's own answer (`UserRecordAccess`) 8. **Field-level security** 9. **Page layout** 10. **Effective visibility** — what the user can actually see and edit For each step it reports: - Whether the user passes, is blocked, or passes only in part - The reason (e.g., "owner," "shared via rule X," "user has View All Data") - For some blocks, a suggested fix with a link (for example, granting Read on the object with a permission set) This helps you find which step is the blocker. For example, if a user can't see a record, Access X-Ray shows whether the issue is object permissions, sharing, field-level security, the layout or the record type. --- See [The 10 Layers of Record Access](https://www.sfdcpolice.com/blog/ten-layers-of-record-access) in the blog for real-world examples. ## Batch Manager: Run, Schedule and Set Up Consumer Goods Batches Without the Developer Console Source: https://www.sfdcpolice.com/blog/guide-batch-manager-cg-batches > Six real use cases: setting up CG batch settings safely, running a batch now, moving a schedule to a quieter hour, removing a stale job, and reading what a run did. Every Salesforce org runs batch Apex: nightly clean-ups, recalculations, integrations. Consumer Goods Cloud orgs depend on them more than most: promotions, account managers, authorization lists and job lists are all built by batches. The usual tools are the Developer Console's anonymous Apex window and the Scheduled Jobs page in Setup. Batch Manager puts all of it on one screen, and it was rebuilt this month after a week of testing on a live Consumer Goods trial org. This guide walks through six real situations, step by step. Every screenshot is from that org. ### The screen at a glance Open **Automation → Batch Manager**. ![Batch Manager's batch list with the CG batches added](https://www.sfdcpolice.com/blog/guides/bm-list.png) *1 Run All starts every batch in your Run All list, in order. 2 Add CG batches to my list. 3 Create CG settings. 4 The tabs: All, In Run All, Scheduled, Running, Failed. 5 Size, and where it comes from. 6 The schedule from the org's batch settings. 7 Run one batch now.* Each row is one batch class. The columns tell you: - **Type**: *Batch* (an Apex batch that processes records in chunks) or *Scheduled* (a class that is meant to be started on a schedule). - **Size**: the batch size a run will use, and where it comes from: *from setting* means it was read from the org's batch configuration; *no setting documented* means Salesforce documents no setting for that class, so the default is shown. - **Schedule**: for a Processing Services batch, what its rows in the org's batch settings say, one line per sales org, for example "0001: No days at 12:00 GMT". For any other batch, its scheduled Apex job, if it has one; click it to open that job on the **Scheduled** tab. - **Status**: *Idle* when there is no recent run, otherwise the latest run's Salesforce status, such as Queued, Processing, Completed, Failed or Aborted. The line under the toolbar says when the job status was last read, for example "Updated 10 s ago · not refreshing by itself, none was running at the last read". Batch Manager only checks Salesforce again by itself while a job is running, and it pauses while the tab is hidden. It used to ask every 3 seconds, which cost about 2,400 API calls an hour per open tab. Press **Refresh** whenever you want a fresh read. ### Use case 1: Setting up a new Consumer Goods org **Situation.** A new CG org has the managed package installed, but nothing runs: promotions don't reach stores, account managers aren't flattened, surveys show no products. The batches exist, but the org has no batch settings and nothing is scheduled. **Steps.** 1. Click **Add CG batches to my list** (the button appears only in a Consumer Goods org). Batch Manager adds the 19 Consumer Goods batches it knows to your list. Nothing is written to Salesforce; the list is kept in this browser. 2. Click **Create CG settings (N)**, where N is the number of settings the org is missing (the button is hidden when none are). A preview opens before anything is saved. ![The Create CG batch settings preview](https://www.sfdcpolice.com/blog/guides/bm-cg-settings.png) *1 A warning when no job named Scheduler is scheduled. 2 What a new Processing Services row will be. 3 Rows that already exist are left as they are. 4 Rows it will not create, and why. 5 Create.* 3. Read each row. The preview tells you, per batch: - **Create**: the exact name, Apex class, job name and start time it will write. Processing Services rows are created **with no days ticked**, and the preview says so: "it won't run until you tick days on the row." This is deliberate: an earlier version ticked all seven days, which would have started every service, complex pricing on every sales org included, at the next midnight GMT. - **Already exists as … Left as it is**: an existing row is never changed. - **Not created**: for example Customer Segmentation runs for one sales org at a time, so its row needs a sales org you choose. 4. If the yellow warning appears ("Processing Services batches run only when the Scheduler class is scheduled, hourly is recommended. No job here is named Scheduler"), schedule the **Main Scheduler** (`cgcloud.Scheduler`) after this step (the warning recommends hourly). Open the Main Scheduler row and click **Schedule the Scheduler class** on its **Config** tab, or use the **+** on the **Scheduled** tab. Without it, Processing Services never start. The check looks for a job whose name contains "Scheduler", because Salesforce doesn't say which class a scheduled job runs. If your Scheduler job has another name, the warning still shows; check that job yourself. 5. Click **Create N settings**. Only the rows marked *Create* are written, to the custom setting **Batch Process Configuration**. Existing rows are not changed. One thing does change: if an Apex batch is already scheduled, its runs read their size from the new row from then on, and the preview says so. 6. Tick the days for the services you want running. Click the batch's row, and on its **Config** tab tick the days on each sales org's row and click **Save Changes**. You can also do it in Salesforce Setup under Batch Process Configuration (then press **Refresh** in Batch Manager). The Schedule column now shows the days. **Good to know.** One custom setting serves two kinds of batch. Apex batches read only their **Batch Size**, from the row named exactly as Salesforce's help table documents. Processing Services rows are found by Apex class and sales org, one per sales org, with days and a start time in GMT. Processing Services on Hyperforce run in Salesforce's Consumer Goods cloud, so the org's debug logs show little of their work. Apex batches run in the org itself, so their logs show every query. ### Use case 2: Running one batch now **Situation.** You changed an authorization list and want the products to appear in surveys and orders now, not tonight. That is the job of **Auth Aggregation** (`cgcloud.AuthorizationListSetupBatch`). **Steps.** 1. Type part of the name in **Search batches** to find it. 2. Click **Run** on its row. The Run dialog explains what you are about to start. ![The Run dialog for Auth Aggregation](https://www.sfdcpolice.com/blog/guides/bm-run.png) *1 The Apex class that will run. 2 Batch size, filled in from the org's setting. 3 Where that size came from. 4 The debug log note. 5 Run Now.* 3. Check the **Batch size**. It is pre-filled from the org's setting (here, the AuthAggregation row says 1). You can change it, and a size you type applies to **this run only**; it is not saved back to the setting. 4. Click **Run Now**. Batch Manager also turns on a 60-minute debug log for you (an existing one is kept), so this run's log can be read afterwards. 5. The row switches to Queued, then Processing. While it runs, the list refreshes by itself with a short back-off, and stops once nothing is running. **Why trust the button.** One click sends exactly one `Database.executeBatch`. We traced the whole path after seeing two jobs start in the same second on a test run, and pinned it with tests. ### Use case 3: Moving a scheduled job to a quieter hour **Situation.** A data loader job runs at 12:51 PM, in the middle of the working day, and slows everything down. You want it at night. **Steps.** 1. Open the **Scheduled** tab. ![Scheduled jobs and the 24-hour schedule overview](https://www.sfdcpolice.com/blog/guides/bm-schedule.png) *1 Drag a job to a new hour; it saves in your Salesforce time zone. 2 A job on the clock. 3 Whose time zone the schedule is in. 4 Delete.* 2. The **Schedule overview** shows the day as 24 columns, in GMT and in your own time zone, with each scheduled job on its hour. 3. Read each job's line, for example "Runs: Daily at 12:51 PM America/New_York (the time zone of the user who scheduled it) · Next: Nov 7, 12:51 PM EST (your time)". *Your time* is your browser's time zone. A cron's hours are wall-clock hours in the zone of the user who scheduled it, not GMT. Batch Manager used to label them GMT, so a job could land hours away from where you dropped it. 4. Drag the job to the new hour. It is saved in **your** Salesforce time zone. If that is different from the job's old zone, the dialog tells you before you confirm. 5. Check the class in the dialog. Batch Manager finds the job's Schedulable class by the job's name; when it can't confirm the match, it says "Matched by name" and asks you to check it. 6. Confirm. Batch Manager first checks that the class can still be scheduled (it exists, has a no-argument constructor and is Schedulable). Only if that passes does it stop the old schedule and create the new one under the same name. If the new schedule fails, it puts the job back at its old time. If even that fails, it tells you exactly how to re-create the job. **Good to know.** Salesforce can't change a scheduled job's time in place, so a move deletes the job and creates it again as you. The job then runs as you, a paused job becomes scheduled again, and it is created with `new ClassName()`, so values a job was scheduled with through its constructor are lost. Only scheduled Apex that runs at a single hour can be dragged. A job that runs at several hours, or a report schedule (it has no Apex class to re-create), stays where it is. ### Use case 4: Removing a stale schedule **Situation.** An old integration is retired, but its scheduled job still fires every night and fails. **Steps.** 1. Open **Scheduled** and find the job by name, owner (*By:*) and next run. 2. Click **Delete** on the job and confirm. 3. Batch Manager stops it with `System.abortJob`. Salesforce refuses the REST delete on a scheduled job (it answers `INSUFFICIENT_ACCESS_OR_READONLY` even for the user who scheduled it), which is why the old Delete button failed. The job Id is checked to be a real scheduled-job Id before any Apex runs. **Careful.** Managed packages schedule their own jobs (the three on our org are package jobs). Delete one only when you know what it does; the package will not recreate it for you. ### Use case 5: Running several batches in order **Situation.** After a data load, you want to kick off the usual set of CG batches in one click instead of eight. **Steps.** 1. Star (**Pin**) the batches you want. They appear under **In Run All**. 2. Use the up and down arrows in the **Actions** column to put them in the order you want them started. The arrows show on the **All** tab when the search box is empty. 3. Click **Run All (N)**. Batch Manager starts them one at a time, in list order, each with its usual size from the settings. If one fails to start, the rest still go. 4. Watch the **Running** tab, and check **Failed** when they finish. **Careful.** *Started in order* is not *finished in order*: Salesforce runs up to five batch jobs at the same time and queues the rest, so a later batch can start before an earlier one has finished. When one batch truly depends on another (for example the account managers need the flattened hierarchy), run them one by one with **Run** and wait for each to complete. Run All also refuses to start if it can't tell a batch's size from the settings, rather than guessing one; it names those batches so you can run them individually. ### Use case 6: Finding out what a run did **Situation.** A batch says Completed, but the data doesn't look right. Did it touch the records you expected? Did any chunk fail? **Steps.** 1. Right after you start a batch, a bar says "Started …" with **Open this run's report**. For an older run, open the batch and click the run in its **Jobs** list. 2. The run report shows the result, the errors per failed chunk in Salesforce's own words, the queries and limits used, and which records were likely changed (on request, because it costs extra queries). 3. Read the small print on each figure. The report only claims what the debug logs can show: row counts say "sent to the database (from logs)", figures say how many chunk logs they come from ("from 3 of 4 chunk logs"), and a dash with a reason replaces a zero that only means "not recorded" (for example managed code, whose details Salesforce hides from logs). ### Quick reference | You want to | Do this | |---|---| | Fill your list with the CG batches | **Add CG batches to my list** (writes nothing to Salesforce) | | Create missing CG batch settings | **Create CG settings**, read the preview, then **Create** | | Start one batch now | **Run** on the row, check the size, **Run Now** | | Use a different size once | Change it in the Run dialog (not saved) | | Move a scheduled job | **Scheduled** tab, drag it to a new hour | | Stop a scheduled job | **Scheduled** tab, **Delete** | | Start several at once | Pin, order with the arrows, **Run All** (started in order, not finished in order) | | Start a batch from a record page | The floating panel's **Batch** tab (see the [floating panel guide](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab)) | This guide describes Batch Manager in SFDC Police 1.1.13. Version 1.1.9 has an older Batch Manager: no run report, no settings preview, a status check every 3 seconds, schedule times labelled GMT, and a Delete that Salesforce refuses. Its **Setup CG configs** button writes the missing settings at once, with no preview and all seven days ticked, so don't use it on an org you care about; wait for 1.1.13. See also the [Batch Manager docs](https://www.sfdcpolice.com/docs/features/batch-manager). ## CG Doctor: Why a Survey, Promotion or Job List Does or Doesn't Show on a Consumer Goods Visit Source: https://www.sfdcpolice.com/blog/guide-cg-doctor > Six real use cases: missing survey questions, missing promotions, job lists that went to the wrong people, and reps who can't read the records a visit needs. In Consumer Goods Cloud, what a rep sees on a visit is decided by a chain of settings: the visit template, the activity's dates and approval, the customer's account sets, the job lists the batches generated, promotions and their stores, and whether the rep can read any of it. When something is missing, finding the broken link usually means a dozen SOQL queries and a lot of guessing. **CG Doctor** walks that chain for one visit and tells you, item by item, whether it **Shows**, **Doesn't show** or **Can't tell**, and which check decided it. It is read only. It says *Can't tell* whenever the org's data can't prove the answer, for example where Salesforce doesn't document a rule. It never guesses. Every example below is from a live Consumer Goods trial org. Where a rule could be tested there, we tested it by creating records and running the real batches (the promotion and job list batches, and the rep's record access). ### Finding the visit Open **CG Doctor** from the top bar. CG Doctor is new in 1.1.13; version 1.1.9 doesn't have it. (In the release after 1.1.13 it moves under a **Consumer Goods** menu and shows only in Consumer Goods orgs.) ![CG Doctor on a planned visit, Survey questions tab](https://www.sfdcpolice.com/blog/guides/cgd-survey.png) *1 The three questions CG Doctor answers. 2 Find the visit. 3 The visit's rep. 4 The verdict counts. 5 The row filter (an earlier "Only problems" box; 1.1.13 has verdict filters instead). 6 The check that decided each row.* 1. Type a visit number, an account or a rep's name, or paste a Visit Id, and click **Find visit**. 2. The visit card shows the visit, account, rep, date, status, visit template and the template's sales org, with links to each record in Salesforce. 3. Pick the tab for your question: **Survey questions**, **Promotions** or **Job list people**. Switching tabs re-reads the same visit. ### Use case 1: "My survey isn't on the visit" **Situation.** A rep opens visit 00000287 at NTO Store #203 and says a survey is missing. **Steps.** 1. Find the visit and stay on **Survey questions**. 2. Read the heading: "Activities on this template: 66 (7 show, 53 don't, 6 can't tell)". Every activity on the visit template is listed, not just the ones that show. 3. Use the verdict filter above the table (**All**, **Shows**, **Doesn't show**, **Can't tell**, each with its count) to see only the rows you care about. The screenshot shows an earlier "Only problems" box that this filter replaced. 4. Read **Why**. It gives the one check that decided the row, in plain words, for example "Visit date is inside the activity's valid dates: The visit (2022-12-27) is after the activity ended (2022-03-10)" or "Activity is active: The activity is inactive, so its questions are not offered." 5. Read **Route**: *Standard, all accounts*, *Standard, targeted*, *Event-driven, targeted* or *Event-driven, not targeted*. A targeted activity needs the visit's account to be targeted. An event-driven one also needs a job list that fits this visit (the visit's rep, account and template). 6. Click a row to expand it. You see every check in order (pass, fail, unknown or not applicable), and the values it read, grouped by record with names and links. On this visit, 53 activities don't show because the visit date is outside their valid dates or they are inactive, and 6 are *Can't tell*. For example "Approval is empty. Salesforce documents that questions need Approved or Not Relevant; what an empty value does is not documented." **What to do.** Fix what the failing check names: extend the activity's dates, activate it, set its approval, or generate the job list. Then click **Find visit** again to re-check. ### Use case 2: "One question is missing" **Situation.** The survey shows, but one question isn't there. **Steps.** 1. On **Survey questions**, scroll to **Questions of the activities that show**. 2. Type the question's name. CG Doctor says why it is or isn't there. Each activity also has a check that it has at least one active, included question (inactive or excluded question links don't count). ### Use case 3: "The promotion isn't on the visit" **Situation.** Visit 00001210 at NTO Atlanta should show a running promotion. ![The Promotions tab](https://www.sfdcpolice.com/blog/guides/cgd-promotions.png) *1 The visit template's promotion settings. 2 How many promotions could apply. 3 The one thing CG Doctor can't prove yet.* **Steps.** 1. Switch to **Promotions**. 2. Check **Visit template promotion settings**: *Display promotions* must be true, and the *promotion-finding lead time* (here 365 days) sets how far ahead promotions are looked for. 3. Read "Promotions that could apply: 43 (0 show, 36 don't, 7 can't tell)". These are promotions anchored on this account, on an account set it belongs to, or linked to it as a store. 4. Read each row's **Why**: "The visit (2026-03-11) is after the promotion ended (2024-05-15)", "The promotion is inactive", and so on. **Why nothing says "Shows".** We tested how Consumer Goods links promotions to stores: the promotion aggregation batch follows the promotion's own Date From and Date Thru on the day it runs. Whether devices also check each tactic's dates isn't documented, so CG Doctor leaves that check at *Can't tell* rather than guess. Promoted products in an order are not checked here. **What to do.** For a promotion that should show: extend its dates or activate it, make sure the account is in its account set or store list, then let the promotion batch run (or start it from [Batch Manager](https://www.sfdcpolice.com/blog/guide-batch-manager-cg-batches)). ### Use case 4: "The activity went to the wrong people" **Situation.** An activity's job lists were generated, but you're not sure the right reps got them. ![Job list people: who the rule picks and who has a job list](https://www.sfdcpolice.com/blog/whats-new-nov-2026/cg-doctor-job-list-people.png) **Steps.** 1. Switch to **Job list people**. It lists the event-driven activities of the visit's template that target the visit's account or already have a job list on it. Each gets a verdict; expand one. 2. The table lists the account's managers and anyone holding a job list: main or not, active, type, valid dates, whether they qualify, whether the rule picks them, their job list (with its Done value) and the result. 3. The rule is Salesforce's: active managers of the activity's management type whose dates overlap the activity, then the activity's **User Policy** (*All*, *Only Main* or *First*) chooses among them. 4. The verdict is **Right people**, **Wrong people** or **Can't tell**, with the check that decided it. **Good to know.** We confirmed live that the job list batch with policy *All* gives every overlapping active manager a job list, and that it only regenerates activities that are still valid. Consumer Goods also blocks editing an active activity's policy or dates, so a fix may mean a new activity. Done values are 0 (Not Done), 1 (Done) and 2 (Canceled). ### Use case 5: "The rep can't see it, but everything passes" **Situation.** Every check passes, but the rep still doesn't see the survey. Often the reason is plain Salesforce access: the rep can't read the account or the activity. ![A rep who can't read the records the visit needs](https://www.sfdcpolice.com/blog/guides/cgd-rep-access.png) *1 The visit's rep. 2 Every activity is now Can't tell. 3 Can't tell. 4 Why: no sharing access to the account, no Read permission on the activity's object.* Every tab now checks whether **the visit's rep can read** the main records behind the answer: the account and the activity (Survey questions, Job list people), or the promotion and its included tactics (Promotions). Questions and job list records themselves aren't checked. It uses Salesforce's own `UserRecordAccess` (which covers sharing and object permissions) plus the rep's object permissions, which say which of the two is missing. On **Job list people** the access result is shown but doesn't change the Right people or Wrong people verdict. On visit 00001258, Steve Rep "can't read account SFP_QA_Hidden_Store (no sharing access)" and has "no Read permission on cgcloud__Job_Definition_List__c", so every activity that would otherwise show becomes *Can't tell*. Why *Can't tell* and not *Doesn't show*? Because whether the Consumer Goods device sync uses the rep's own access isn't documented. CG Doctor shows the access gap and tells you how to settle it: check the rep's sharing (rules, role, account team) and profile or permission sets, or ask your CG admin how device sync is set up. Restriction rules are not covered by `UserRecordAccess`. To see the full access picture for that rep and record, use the floating panel's **Access → Record** check ([guide](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab)). ### Use case 6: Checking a fix After you change something (dates, approval, account set, sharing, or a batch run), click **Find visit** again. CG Doctor reads everything fresh, so the counts and verdicts reflect the org as it is now. It writes nothing, so you can run it as often as you like, in production too. ### What each verdict means | Verdict | Meaning | |---|---| | **Shows** | Every check CG Doctor knows passed. | | **Doesn't show** | A documented rule says no; *Why* names it. | | **Can't tell** | The org's data can't prove it either way, usually because Salesforce doesn't document the rule, or the rep's access is in question. The expanded row says what would settle it. | CG Doctor is new in SFDC Police 1.1.13; it is not in 1.1.9. Reference: [CG Doctor docs](https://www.sfdcpolice.com/docs/features/cg-doctor). ## Moving and Making Test Data: Data Migrator and Data Generator, End to End Source: https://www.sfdcpolice.com/blog/guide-data-migrator-and-generator > Two real runs, step by step: migrating filtered accounts between orgs (when 40 of 41 already exist) and generating related test records, then undoing both. Sooner or later every admin needs data somewhere it isn't: real records copied from one org to another, or realistic fake records in a sandbox. SFDC Police has a tool for each. **Data Migrator** copies existing records between orgs. **Data Generator** creates new, realistic records with their relationships. Both can undo what they wrote. This guide follows two real runs we did on live trial orgs this week, including the parts that didn't go smoothly, because that is where the tools earn their keep. ### Part 1: Data Migrator #### When to use it - **Seeding a sandbox** with a slice of production: the accounts of one region, the last 90 days of cases. - **Moving configuration data** (templates, reference records) from a build org to test or production. - **Keeping two orgs in step** with Delta mode, which only sends records changed since the last run. - **Repeating a migration safely**: matching by an external Id updates what is already there instead of creating duplicates. #### The run: 41 filtered accounts into a second org We moved every Account whose name starts with `SFP_QA_` from one test org into another, insert only. Most of them already existed in the target, which made it a good test of what the tool reports. The migrator is a six-step wizard: **Connect → Objects → Matching → Filters → Preflight → Run**. Nothing is written until the last step. **Step 1, Connect.** Pick the source and target orgs. Both must be open in Chrome; the list shows only orgs with a live session. **Step 2, Objects.** Search for the objects to move, or start from an object pack. Related objects can be discovered automatically, and the migrator works out the dependencies and the load order (parents before children). **Step 3, Matching.** For each object, choose how records are matched in the target: *Insert only* creates every row; an upsert strategy matches on an external Id or another field and updates instead. *Auto-detect all* picks a strategy per object. This step also holds field mapping, user mapping (owners matched by username, then email), record type mapping and **lookup mapping** for lookups that point outside the migration. We chose *Insert only*. **Step 4, Filters.** ![Data Migrator Filters step](https://www.sfdcpolice.com/blog/guides/dm-filter.png) *1 How many records the filter matches. 2 The filter. 3 Delta mode. 4 The fields that will be sent.* 1. Click the object's row to open it. 2. Type a **WHERE clause** (`Name LIKE 'SFP_QA_%'`), or build one with **Quick add**. 3. The **Records** column updates: ~41 of 41 total. 4. Optionally set **ORDER BY**, tick **Delta mode** to send only records changed since the last run, and choose fields: **All**, **None** or **Required**. **Step 5, Preflight.** ![The Preflight review](https://www.sfdcpolice.com/blog/guides/dm-preflight.png) *1 Estimated records. 2 Risks, in plain words. 3 Parent hierarchy. 4 Start Migration.* This is the last look before anything is written: - **Summary**: mode, objects, estimated records, operations and target org. - **Risks**: here, "This inserts every row. Account has no external Id or match fields to match on, and the target already has 108 Account rows, so any row already there is added again." Exactly the warning you want before creating duplicates. - **Validation**: target connected, objects selected. - **Parent hierarchy**: when you filter, records may point at parents you didn't select (for example an account's parent account). Tick **Auto-include parent records of filtered records** to bring the ancestor chain along; otherwise that lookup is left blank. - **Permission Parity** checks that you (the running user) can create, read and edit the objects and fields in the target before you run; **Risk** and **Access** open the matching checks. Click **Start Migration**. Because the target was a production org, a confirmation named it and the record count before going ahead. **Step 6, Run.** ![The run result: 1 written, 40 failed](https://www.sfdcpolice.com/blog/guides/dm-result.png) *1 The outcome. 2 Comparison report. 3 Rollback. 4 Errors.* The result: **1 written, 40 failed**, in 2 seconds. That was correct: 40 of the accounts already existed in the target with the same value in a unique external Id field, so Salesforce refused them with `DUPLICATE_VALUE`. The one account that didn't exist yet was created. The run screen gives you four ways forward: - **Errors (40)** opens **Error Surgery**, which groups errors by cause and offers a fix for the whole group. For `DUPLICATE_VALUE` it offers to map each row to the existing record the error names, which you **Apply** or **Skip**. **Retry All** re-sends the failed rows. - **Comparison report** opens the side-by-side view of the run. - **Reconcile** runs a post-migration check of the target against the source and adds it to the run report. - **Rollback** undoes this run. #### Undoing the run We clicked **Rollback** and confirmed. ![After the rollback](https://www.sfdcpolice.com/blog/guides/dm-rolled-back.png) *1 "Migration rolled back: 1 record it created deleted." 2 The run now says rolled back. 3 Error Surgery, grouped by error code. 4 The suggested fix. 5 Informational notices.* Rollback deleted exactly the one record the run created and touched nothing else; we confirmed in the target org that it was gone. The **Informational notices** section explains things that are not failures, here `ASSIGN_USER_FALLBACK`: one row's owner had no matching user in the target, so it was assigned to the user running the migration. #### Tips for your own migrations - Give migrated objects an **external Id** and match on it. Re-running then updates instead of duplicating, and the Risks card stops warning. - Read the **Risks** card every time. It is written to be read, not skimmed. - Large parent filters are handled for you (from 1.1.13): when a list of parent Ids would make the query too long for Salesforce, the migrator reads wider, keeps only the rows of the parents you extracted, and says so in the run. - Run against a sandbox first. The production confirmation is there for a reason. ### Part 2: Data Generator #### When to use it - **A fresh sandbox with no data** that testers need to click through. - **Testing automation at volume**: a flow that should handle 200 contacts per account. - **Hierarchies**: accounts with parent accounts several levels deep. - **Demo orgs** that should look real, with real-sounding company names, phone numbers and descriptions. #### The run: 5 accounts and 10 contacts in a Consumer Goods org **Step 1, choose objects.** We added Account (5 records) and Contact (10 records), then clicked **Discover Dependencies**. It found 6 related objects with 10 dependencies: lookups our records need, such as Record Type, Operating Hours and the CG Customer Template. **Step 2, configure.** ![Data Generator configuration](https://www.sfdcpolice.com/blog/guides/dg-config.png) *1 Selected objects and how many records each. 2 Hierarchy: depth and how many records are roots. 3 How each field is filled. 4 Dependencies. 5 Preview.* - **Hierarchy**: Account's Parent Account is a self-lookup, so you choose the depth (3 levels) and the share of top-level accounts (33%) and a pattern (Balanced). - **Record type distribution**: how the records spread over record types. - **Fields**: each field has a strategy: *Realistic* values, *Pick records* (for lookups, existing records), *Link to record* and others. **Essentials** shows the fields that matter; **All fields** shows everything. - **Dependencies**: lookups are filled from **existing records** in your org (here Record Type, Operating Hours and Customer Template). When an object has no records to link (here *Individual*), the link is left blank, and **Generate new** creates some instead. **Step 3, Preview.** ![The generated records before insert](https://www.sfdcpolice.com/blog/guides/dg-preview.png) *1 The Preview tab. 2 Generated rows, with real-looking values. 3 Insert into Org.* Every row is visible before anything is written: names like *Signal International* and *Pioneer Analytics*, phone numbers, owners, account numbers. Change a setting and preview again until it looks right. **Step 4, Insert.** Click **Insert into Org**. Our run took 13 API calls: 6 describes, 3 queries, 2 inserts and 2 updates. The updates are the hierarchy: a record can only point at its parent once the parent exists, so Parent Account links are set in a second pass after the insert. All 15 records were created. The result also told us something useful: **3 links were not set**. Under **Needs linking**, each of the 3 accounts shows Salesforce's own reason: > FIELD_CUSTOM_VALIDATION_EXCEPTION: The Parent Customer and the Customer Template must have the same Sales Org. That is a Consumer Goods validation rule doing its job: the generator gave each account an existing Customer Template, and three child accounts got a template from a different sales org than their parent. The accounts themselves were fine; only their Parent Account was left blank. 1.1.13 calls this "Done — some links not set" and shows Salesforce's reason on each row, as above. (Version 1.1.9 calls it "Done — with some failures" and shows the reason only through **Copy errors**.) **What to do about it:** turn the hierarchy off for Account if you don't need parent accounts, or set the Parent Account links afterwards in Salesforce on accounts that share a sales org. **Needs linking** lists exactly which records are affected. #### Undoing the run 1. Click **Undo all 15**. 2. The button turns into **Delete 15? Click to confirm**. Click it again within a few seconds. 3. The status changes to **Rolled back** and the summary says "15 records deleted from your org". We checked the org afterwards: none of the 15 records remained. #### Tips for generated data - Start small (5 to 10 records per object), check the preview and the result, then scale up. - **Discover Dependencies** before configuring; it saves a round of "required field missing" errors. - In orgs with strict validation rules (Consumer Goods has many), read **Needs linking** after a run: it tells you which rule said no. - Save a setup you like with **Templates** and reuse it in the next sandbox. ### Which one do I need? | You want | Use | |---|---| | The same records that exist in another org | Data Migrator | | Records that don't exist anywhere yet | Data Generator | | To update records already in the target | Data Migrator with an upsert match | | Volume for testing automation | Data Generator | | To undo a run | Rollback (Migrator) or Undo all (Generator) | This guide shows both tools in SFDC Police 1.1.13. Most of it also works in 1.1.9; what 1.1.9 doesn't have: the **Risks** warning that rows already in the target will be added again, the `ASSIGN_USER_FALLBACK` notice, the wider read for large parent filters, and the Data Generator's per-row reasons under **Needs linking**. Reference docs: [Data Migrator](https://www.sfdcpolice.com/docs/features/data-migrator), [Data Generator](https://www.sfdcpolice.com/docs/features/smart-data-generator). ## The Floating Panel, Tab by Tab: Every Tool You Get on a Salesforce Record Source: https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab > A complete guide to the SFDC Police floating panel with real use cases for each tab: Actions, Access (record and user), Query, History, Move, Batch and Status. The floating panel is the part of SFDC Police you use without leaving Salesforce. Click the SFDC Police icon in Chrome's toolbar on any Salesforce page and the panel opens on top of it, already knowing which org you are in and which record you are looking at. Click the icon again (or the ✕) to close it. It has seven tabs: **Actions, Access, Query, History, Move, Batch** and **Status**. **Move** only appears on a record page. The panel shows as many tabs as fit its width and puts the rest behind the **⋯** button (at the usual width, **Batch** and **Status**); the small number on ⋯ is how many tabs are tucked away. A red **PRODUCTION** strip across the top reminds you when you are in a production org. Every screenshot below was taken on a Consumer Goods Cloud account record, *NTO Store #203*, in a live trial org. Email addresses and the org Id are blurred. ### Actions: what you can do with this record ![The Actions tab on an Account record](https://www.sfdcpolice.com/blog/guides/fp-actions.png) *1 What you are on. 2 One-click tools for this record. 3 Tools suggested for this page. 4 Every tool.* **What it is.** The starting point. It names what you are on ("You're on Account record") and gives you the tools that make sense there. - **Copy Id** and **Copy link** put the record Id, or a short link to the record (`https://your-org/001…`), on your clipboard. - **Fields** shows this record's field values right in the panel, by API name. - **Describe** shows the object's describe (fields, types, settings) in the panel; **Schema** shows the objects it is related to. - **Suggested here** lists the tools most useful on this kind of page. On a record: Related Records, SOQL Builder and Org Process Graph. Tools you pin (the star) or use often show above it as **Pinned** and **Frequent**, and are not repeated below. - **All tools (28)** lists the rest of SFDC Police's tools, so you never need to remember where a tool lives. The number is how many are left once Pinned, Frequent and Suggested are taken out. #### Use cases - **Sharing a record in a ticket.** *Copy link* gives a short link that opens the record for anyone who can see it. - **"Which field is that?"** Open *Fields* to see the API names and values behind the page before writing a formula, a flow or a query. - **"What is connected to this account?"** *Related Records* from *Suggested here*. ### Access → Record: who can see this record, and why ![Access → Record](https://www.sfdcpolice.com/blog/guides/fp-access-record.png) *1 Check a user's access to this record. 2 Object, Id and key prefix, with copy buttons. 3 Shortcuts to the object's fields, record types, list view and access settings. 4 Owner, record type, created and modified.* **What it is.** Facts about the record plus the most common access question. #### How to check one user's access 1. Open the record and the panel, then **Access → Record**. 2. In **Check a user's access to this record**, type a name or email and pick the user. 3. **Access X-Ray** opens with the verdict (Read / Edit / Create / Delete) and ten layers: object permissions, org-wide default, ownership, role hierarchy, sharing rules, system bypass permissions (View All, Modify All), Salesforce's own record-access verdict, field-level security, page layout and record type access. 4. Open a layer for its detail. **Hide access check** collapses it; the ✕ in the search box lets you check another user. From version 1.1.13 the check opens as soon as you pick the user. In 1.1.9 the section has no title; after picking the user, click **Access X-Ray** to open it and again to close it. On our org, a rep without View All on a Private Account got "No access — record is invisible", and a rep with View All on Account got "Read". Both match Salesforce's own `UserRecordAccess` answer. #### Use cases - **"My rep can't see this account."** Pick the rep and read which layer says no: usually the org-wide default with no role or sharing-rule grant. - **"Why can this intern see salaries?"** The System Bypass layer names permissions like View All Data, and Object Permissions shows the profile or permission set it comes from. - **Before and after a sharing change.** Check one user who should keep access and one who should not. To look at a *different* object's details, use **Look up another object** at the bottom of this tab (from version 1.1.13). It lists up to 50 matches, says how many more there are, and leaves out Share, Feed, History and ChangeEvent objects unless you type those words. ### Access → User: one user, everything about them ![Access → User](https://www.sfdcpolice.com/blog/guides/fp-access-user.png) *1 Search for a user. 2 Edit User, Enable Debug, View Logs, Reset Password. 3 Open in Access Editor.* **What it is.** A user card: name, username, email, profile, role, status, last login and user Id, with the actions you need most often when someone reports a problem. Below it are the user's permission set groups and permission sets. For an active user other than you, **Login As** (and **Incognito**) also appear. #### Use cases - **"It doesn't work for me."** Pick the user and click **Enable Debug**, ask them to try again, then **View Logs** to read what happened. - **"Can you check my access?"** **Open in Access Editor** opens that user in the full-page Access Editor. - **Locked out.** **Reset Password** asks you to confirm first, then has Salesforce email the user a reset link. It needs the Manage Users permission and does not work on your own user. - **Is this account still used?** *Status* and *Last Login* answer it without opening Setup. ### Query: run SOQL right on the record, and find related records without writing joins ![The Query tab with related queries](https://www.sfdcpolice.com/blog/guides/fp-query.png) *1 The query editor, filled in for this record. 2 Related queries. 3 Linked through a junction object. 4 Run.* **What it is.** A query editor that starts with this record's query (`SELECT Id, Name FROM Account WHERE Id = '…'`). Press ⌘↵ (Ctrl+Enter on Windows) or **Run**. **Builder ↗** opens the same query in the full SOQL Builder. **Related queries** (from version 1.1.13) writes the query for you. It lists the objects related to this record, in three groups. It leaves out system objects (Share, History, Feed and the like) and the owner, created-by, last-modified-by and record-type lookups. - **Linked through a junction object**: one `IN` query per route. On an account, *Customer Sets via Customer Set Customers* gives the customer sets the account belongs to, through the junction object, without you writing a semi-join. It looks for junctions among the first 30 child objects (your custom objects first), so on an object with very many children some routes may be missing. - **Child records**: this record's children, for example its visits or job lists. - **Parent records**: the records this one points to, for example its customer template. #### How to use it 1. Click **Related queries**. 2. If there are more than eight suggestions, type in **Filter related objects** to narrow the list (an account can have hundreds of relationships). 3. Click a suggestion. It goes into the editor; nothing runs until you press **Run**, so you can add fields or filters first. #### Use cases - **"Which customer sets is this store in?"** One click instead of a nested query. - **"Show me this account's visits from last week."** Pick *Visits*, add `AND CreatedDate = LAST_WEEK`, run. - **Learning an unfamiliar data model.** Browse the three groups on a record you know. ### History → My actions: what you changed through SFDC Police ![History → My actions](https://www.sfdcpolice.com/blog/guides/fp-history-mine.png) *1 My actions. 2 Your changes appear here.* **What it is.** Your own most recent changes made through SFDC Police: record edits, permission set assignments, and object and field permissions. The panel shows the last five, each with its time and whether it worked; **View All Transactions** opens the full list. Until you change something it says so plainly ("No changes yet"). For the record's own field history, use *Record trail*. #### Use cases - **"What did I just change?"** The last few changes are one click away, with any that failed marked. - **Writing up a change.** Open **View All Transactions** for the full list to put in the ticket or change log. ### History → Record trail: what automation touches this record ![History → Record trail](https://www.sfdcpolice.com/blog/guides/fp-history-trail.png) *1 Record trail. 2 Capture run log. 3 Automations on this object. 4 Field Change History.* **What it is.** Everything that can change this record, and what did: - **Capture run log** turns on debug logging for *your* user for about 30 minutes. Edit and save the record yourself, then click **View captured log**: it opens Debug Logs, filtered to you and refreshing on its own, and the log of that save shows which flows, triggers, workflow rules and validation rules ran. It only logs saves you make, not saves by other users or integrations. - **Automations on Account** lists the triggers, flows, validation rules and workflow rules on the object, active and inactive (here "2 active · 6 inactive"). - **Field Change History** shows the last 20 tracked field changes on this record. It only works for fields with field history tracking turned on. - **Process Graph** opens the full automation map for the object. #### Use cases - **"Something keeps overwriting this field."** Turn on *Capture run log*, save the record yourself, and read in the log which automation set it. If the overwrite comes from another user or an integration, turn on logging for that user instead (Access → User → **Enable Debug**). - **"Was this value changed or entered wrong?"** *Field Change History* shows who changed it and when (for tracked fields). - **Before deactivating a flow.** See what else runs on the object first. ### Move: copy this record to another org (Beam) ![The Move tab](https://www.sfdcpolice.com/blog/guides/fp-move.png) *1 Pick the target org. 2 Refresh the list of orgs. 3 Include parents or children. 4 Analyze move. 5 Import all related.* **What it is.** Copies the record you are on into another org you are signed in to, with its parents and children if you want. It writes to the target org for real, so read the plan before you click **Beam**. #### How to use it 1. Open the target org in another tab first, so you have a live session there. 2. Under **Move to**, pick it. Orgs are listed by name and host (for example "ABCD · orgfarm-…"); press refresh if it is missing. 3. Parents the record needs (required lookups) always come along. Tick **Include parent hierarchy** to also bring optional lookup parents (for example the parent account), and **Include child records** for the record's direct children (up to 50 per relationship, from the first 25 relationships). **Import all related** turns on parents, children and a scan of up to 200 child relationships, and analyzes everything in one click. The API budget is checked first when children are included. 4. Click **Analyze move** and read the plan. Each record shows what will happen to it and how many fields will be copied: - **create**: a new record in the target. - **upsert**: the record has an external ID value, so Beam upserts on it. If the target already has a record with that external ID, Beam **updates that record** with the source values. This is the default whenever an external ID is filled in. - **reuse**: a target record with the same name was found, and Beam links to it without changing it. You can change the choice per record, for example to **Create new**. 5. Click **Beam**. The panel reports how many records were created and how many were reused (a record updated by an upsert counts as reused). 6. **Undo** deletes only the records this move created. It does not put back the values on records that were updated by an upsert. We tested this from the CG org into a second org: the account was created in the target with its fields. Before beaming into an org that matters, check the plan for **upsert** rows: they overwrite fields on records that already exist there. #### Use cases - **Reproducing a production bug in a sandbox** with the exact record. - **Seeding a demo or training org** with a few realistic records and their parents. - **Copying a configuration record** (for example a template) between orgs. ### Batch: start a batch from any page ![The Batch tab](https://www.sfdcpolice.com/blog/guides/fp-batch.png) *1 Batches and Run Apex. 2 Run all. 3 Run one batch. 4 Its schedule.* **What it is.** The [Batch Manager](https://www.sfdcpolice.com/blog/guide-batch-manager-cg-batches) list, in the panel: each batch with its status and either its size (Apex batches) or its schedule from the Consumer Goods setting (Processing Services batches), a **Run** button per batch, and **Run all** for your Run All list. While a job runs it shows progress and an **Abort** button. From version 1.1.13 it only checks Salesforce again while a job is running. **Run Apex** is the second view: search for an Apex class by name and the panel works out how it can be started (as a batch, a queueable, a schedulable, a static method or just its constructor). You confirm the entry point and it runs as anonymous Apex in the org you are on, optionally capturing the debug log. You don't write the anonymous Apex yourself. It runs for real: whatever the class changes is changed. #### Use cases - **Re-running a CG batch while looking at the record it should fix**, then refreshing the page to check. - **Running a one-off Apex class** (a data fix someone wrote) without opening the Developer Console. ### Status: which org, which user, how much API left ![The Status tab](https://www.sfdcpolice.com/blog/guides/fp-status.png) *1 Connection. 2 Org name, instance, domain and type. 3 API calls made and the org's daily limit. 4 View API Dashboard.* **What it is.** A quick health card: whether SFDC Police is connected, who you are signed in as, the org's name, Id, instance, domain and type (Production or Sandbox), how many API calls SFDC Police has made (and how many were served from cache), and the org's API usage against its limit. #### Use cases - **"Am I in the right org?"** Before a risky change, check the name and type. - **"Are we close to the API limit?"** *SF Limit* shows the org's API requests used against its allowance (Salesforce counts this over a rolling 24 hours, and it includes every integration, not just SFDC Police). **View API Dashboard** shows which SFDC Police features made calls and forecasts when the org would hit the limit. ### Tips - The panel follows you: open a different record and every tab updates. - Press Escape to close it. - Everything the panel reads goes through your own Salesforce session; nothing is sent anywhere else. The one exception is **Move**, which writes to the other org you pick, through your session there. This guide describes SFDC Police 1.1.13. If you still have 1.1.9 (chrome://extensions shows your version), you get every tab, but not **Related queries**, **Look up another object** or the access check opening on its own; those come with 1.1.13. Full reference: [Floating panel docs](https://www.sfdcpolice.com/docs/features/floating-panel). ## Process Graph: See the Automations That Run When a Record Is Saved, in Order Source: https://www.sfdcpolice.com/blog/guide-process-graph > Set up a scan (objects, Fast or Full, Customise), read the Dashboard and Map, and work through six real use cases from field overwrites to blocked saves. When an Account is saved, Salesforce may run before-save flows, before triggers, validation rules, after triggers, workflow rules, after-save flows and roll-up summaries, in a fixed order. When a field changes unexpectedly or a save is blocked, the question is always the same: *which of these did it?* **Process Graph** scans the objects you choose and lays out the automations it can read in execution order, with the fields each one reads and writes. It reads active flows only, never reads managed-package Apex code, and says in the report what it left out. Version 1.1.13 adds a guided setup screen, a **Full** mode that reads every active record-automation flow in batches, and **Customise** to choose what a scan reads. (1.1.9, the previous version, has a Fast/Full switch but no setup screen and no Customise.) Every screenshot below is from a live Consumer Goods trial org. ### Setting up a scan Open **Automation → Process Graph**. Before a graph exists, it opens on a three-step setup screen. ![The Process Graph setup screen](https://www.sfdcpolice.com/blog/guides/opg-setup.png) *1 Scan every object. 2 Pick objects. 3 Fast. 4 Full. 5 Customise. 6 Scan.* **1. Choose objects.** Tick the objects you care about. The checklist opens with the objects most automation runs on, then your own custom objects ahead of package ones; a search ranks by relevance; ticked objects rise to the top. **Scan every object** scans every object automation can run on. It leaves out objects Salesforce marks as not triggerable (change events, feeds, history, sharing and similar), and shows the object count and expected API calls in a confirm before it starts. **2. Choose depth.** The cards show real numbers for *this* org: - **Fast** reads the first 100 active flows in the org and 100 Apex classes, starting with the classes your triggers and flow actions name. It may miss some on your objects, and the report says if it does. - **Full** reads every active flow of the kinds that run on records (not screen, routing or other app-specific flows) and up to 2,000 of your org's own Apex classes. Managed-package code is never read. It costs about one API call per flow and per class, so before reading flows SFDC Police checks your API budget against the number of flows, then reads 25 flows at a time with a progress count. You can abort between batches. On our org the card says "14 record-automation flows, 7 Apex classes in this org. This org is under both limits, so Fast and Full read the same." On a large org that line tells you whether Fast is enough. **Customise** has one checkbox per kind: flows and Process Builder, Apex triggers, Apex classes, validation rules, workflow rules and email alerts, approval processes, and formula and rollup fields. All are on by default and at least one must stay on. Untick a kind and the scan makes no calls for it. The report, the banner and the field tooltips then say it was skipped, and any answer that depends on it (such as whether two automations can overlap on a field) is withheld rather than guessed. **3. Scan.** Click **Scan N objects**. The page shows the phase and count; **Abort** stops it (it says *Stopping* while the last requests return). ### Reading the result: Dashboard ![The Dashboard after a Fast scan of Account](https://www.sfdcpolice.com/blog/guides/opg-dashboard.png) *1 What the scan read, and how long it took. 2 What it couldn't read. 3 Filter by operation. 4 Risk score. 5 The save order, phase by phase. 6 Snapshots.* - The **coverage line** says what was scanned ("21 items scanned · 7.3s (Fast mode)"); **Details** lists it. - **Notes** name the gaps honestly: "1 managed trigger can't be read, so what it changes is unknown." - **Fires on** filters by operation: Insert, Update, Delete, Upsert, Undelete. - The cards count **Automations**, the fields that **Can overlap** (two automations proven to change them on the same save, with the "can't tell" count under it), and **No caller found** (automations, mostly Apex, that nothing in the scan starts), plus a **Risk score** worked out from those counts. - **Hottest fields** are the fields touched by the most automations. - **Automation lifecycle** lists the automations in the order Salesforce runs them: *Before save* (before-save flows, before triggers, validation), *After triggers & Apex*, *After save* (workflow, processes, after-save flows), *Async & commit* (roll-ups, formulas, platform events), *On delete* (delete flows) and *Outside the save order* (called code, inactive). The compact row at the top keeps everything one click away: object chips, **+ Add**, **Dashboard / Map**, **Fast / Full**, **Customise**, **Re-scan**, **Snapshots** and **Export**. ### Reading the result: Map ![The Map: fields, automations in run order, and what happens](https://www.sfdcpolice.com/blog/guides/opg-map.png) *1 The summary. 2 The object's fields. 3 Automations in run order. 4 What happens. 5 An inactive automation.* The Map reads left to right: **fields** → **automations** (in run order, grouped by phase) → **what happens**. A solid line means the automation *changes* the field; a dashed line means it *reads or checks* it. Click a field or an automation to highlight its path. The **Show** chips filter by kind of automation (flows, triggers, validation rules and so on; only the kinds this object has appear). The Map only claims what it can prove. A field gets a *can overlap* tag only when the scan proves two automations change it on the same record in the same save. Anything it can't prove reads *can't tell*, with the reason in plain words: for example, an automation's conditions are in Apex code, or part of the org wasn't read (a skipped kind, a cap, managed code). ### Use case 1: "What runs when I save an Account?" 1. Scan Account. 2. On the **Dashboard**, pick the operation in **Fires on** (for example *Update*). 3. Read the lifecycle top to bottom: that is the order Salesforce runs them. Expand a phase to see each automation. ### Use case 2: "Something keeps overwriting this field" 1. Open the **Map** and click the field in the left column. 2. Follow its solid lines: those are the automations that change it, in run order. 3. Click **Open trace** to step through the save. It shows which automations change the field, and which value is kept when the scan can tell. If the field is tagged *can overlap*, two automations both change it on the same save: fix one of them. If it says *can't tell*, the reason names what to check. 4. To catch it in the act, use the floating panel's **History → Record trail → Capture run log** on a real record ([panel guide](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab)). ### Use case 3: "Why can't users save this record?" 1. Open the **Map**. Under **What happens**, **Blocks the save** lists the active validation rules that can reject a save (4 on our Account), and any approval process that locks the record while it is pending. Errors thrown from Apex code are not listed there; if the error message doesn't match one of these rules, look at the triggers in the Automations column. 2. Its lines lead back to the rules in the Automations column (here *Avoid_Change_External_ID*, *CGCloud_Prevent_Account_Template_Change*, *Only_One_Extension* and *Sales_Org_should_be_same*), and from each rule to the fields it checks. Sales-org rules like these are what the [Data Generator](https://www.sfdcpolice.com/blog/guide-data-migrator-and-generator) ran into when it linked accounts across sales orgs. ### Use case 4: Checking a release 1. Before deploying, scan the objects involved and save a snapshot (**Export → Save Snapshot**). 2. Deploy, then **Re-scan** with the same objects, depth and Customise choices. 3. Open **Snapshots** and compare the saved one with the current scan: automations added and removed, and links between automations and fields added and removed. A kind of automation that either scan skipped or failed to read is listed as "Not compared" instead of showing as removed, and the compare warns when one side read only part of the org or the two cover different objects. ### Use case 5: Scanning a big org without burning API calls 1. Start with **Fast** on the objects you need. The depth card tells you whether Fast reads everything on this org. 2. If you only care about flows and triggers, untick the other kinds in **Customise**. 3. Switch to **Full** only when the report says Fast missed something. Before reading flows, the API budget check runs with the real number of flows. It adds a warning to the report when the read would use over 80% of the calls the org has left, and stops the scan when it would use over 95%. ### Use case 6: Clean-up - Automations tagged **inactive — never runs** (here a workflow, *SetExternalId*) are candidates for deletion. - **No caller found** counts automations, mostly Apex classes, that nothing in the scan starts. Check them before deleting: a class can also be called in ways a scan can't see, which is why the wording is "no caller found", not "unused". ### Tips - **Export** the graph to share it or attach it to a design document. - Field tooltips on Salesforce pages use Salesforce's own dependency data for custom fields. For standard fields, or when that data isn't available, they use your last Process Graph scan, and if that scan was partial they say "at least" rather than claiming that's all. - Re-scan after any deployment; a graph shows the org as it was when scanned. Process Graph is part of SFDC Police 1.1.13. Reference: [Process Graph docs](https://www.sfdcpolice.com/docs/features/org-process-graph). ## Related Records: What Is Connected to a Record, Counted in Seconds and One Click from SOQL Source: https://www.sfdcpolice.com/blog/guide-related-records > A hands-on guide with six real use cases: cascade deletes, migration clean-up, support tickets, handing a list to SOQL Builder, and reading formula links. Salesforce shows a record's related lists, but only the ones on the page layout, a few rows at a time, and with no way to query them further. **Related Records** shows what is connected to a record: the parent records its lookups point to and every child list that has records, with counts, and hands any list to SOQL Builder in one click. Version 1.1.13 makes it much faster on records with many relationships, and adds readable list names, a filter, and **Copy SOQL** and **Open in SOQL Builder** on every list. (1.1.9, the previous version, has none of these.) Everything below was tested on a Consumer Goods account with 23 related lists. ### Opening it - From SFDC Police's tools: **Related Records**, then paste a record Id, or pick an object and search its records by name. - From a record page: open the floating panel, **Actions → Suggested here → Related Records**. It opens on the record you are on. ### The screen ![Related Records with readable list names, a filter, and Copy SOQL / Open in SOQL Builder](https://www.sfdcpolice.com/blog/whats-new-nov-2026/related-records-names-filter.png) *1 Filter the lists. 2 A list, by its readable name. 3 Copy SOQL. 4 Open in SOQL Builder.* - **The record card** at the top, with **Open in Salesforce**. - **Parents**: each filled-in lookup on the record and the record it points to. It reads up to 20 fields of the record, so on an object with a great many lookups some may not appear. - **Child lists**: one per relationship that has records, largest first, named the way Salesforce names the object (*Visits*, *Job Lists*), with the relationship's API name underneath and a count. Relationships with no records, and deprecated or non-queryable ones, are left out. #### How it loads fast The record card and parents appear in about a second. Child lists fill in as their counts arrive, and the heading says "still counting…" until the last one; you can open a list while the rest are counted. Counting used to cost one `COUNT()` query per relationship: on our CG account that took about 10 seconds and about 150 API calls. From version 1.1.13, Related Records asks Salesforce, 20 relationships per query, whether each list has any rows at all, and only counts the ones that do. If Salesforce refuses one of those queries, it falls back to counting that group one by one. The same account now loads in about 2 seconds with about 30 calls, and shows the same lists and counts. ### Use case 1: "What would deleting this account take with it?" 1. Open the account in Related Records. 2. Click **Cascade impact**. The inspector on the right switches to its **Cascade** tab and counts the child records Salesforce marks for deletion along with the record: master-detail children, plus standard ones Salesforce also deletes (such as an account's contacts). It looks one level down only, so it does not count grandchildren that would go too. It only reads; it never deletes anything. 3. Remember Salesforce's rules for the rest: a lookup child normally stays and its lookup is cleared, unless the lookup is set to block deletion, in which case the delete is refused while children exist. 4. Open the child lists involved to see the actual records before you delete anything. ### Use case 2: Cleaning up before a migration 1. Open a sample account. 2. Type in **Filter related lists** (it appears when there are more than five lists) to narrow to what you are moving, for example "visit" or "job". The filter matches the list name, the API name and the object. 3. Compare the counts across a few accounts to estimate volumes, then plan the [Data Migrator](https://www.sfdcpolice.com/blog/guide-data-migrator-and-generator) run. ### Use case 3: Investigating a support ticket **Situation.** "A visit is missing from this store." 1. Open the store's account and the **Visits** list. 2. Use the date chips (**Today**, **This week**, **Last 7 days**, **Last 30 days**) to narrow by created date. 3. Open the visit from the list. If it isn't there, no visit you can see points to this account: it may never have been created, been deleted, or be linked to a different account. Check [CG Doctor](https://www.sfdcpolice.com/blog/guide-cg-doctor) (from version 1.1.13) for why something doesn't show on a visit that does exist. ### Use case 4: Taking a list further in SOQL A list shows 10 records at first, and **Load more** pages through more (up to 2,000, Salesforce's limit for paging). When you need all of them, filtered or exported: 1. Open the list and click **Open in SOQL Builder**. The list's own query opens there, without the 10-row limit. ![The list's query opened in SOQL Builder, returning all 27 records](https://www.sfdcpolice.com/blog/whats-new-nov-2026/soql-builder-handoff.png) 2. Add fields or filters, then run, edit or export. 3. Or click **Copy SOQL** to paste the exact query into a ticket, so a teammate runs exactly what you saw. ### Use case 5: Reading formula links Hyperlink and image formula fields used to show as raw HTML (``). From version 1.1.13 they show as a link or plain text; an image formula shows its alt text (or "[image]"), not the picture. Only http(s) and relative links become clickable; anything else is shown as text. ### Use case 6: Learning an unfamiliar data model Open a record you know, say an account, and read the child lists from top to bottom: each name, API name and object tells you how the org's data hangs together, including managed-package objects. Then open the same record in the floating panel's **Query → Related queries** (from version 1.1.13) to get ready-made queries for its relationships, including junction-object routes ([panel guide](https://www.sfdcpolice.com/blog/guide-floating-panel-every-tab)). ### Quick reference | You want to | Do this | |---|---| | See everything connected to a record | Open it in Related Records | | Find one list among many | **Filter related lists** | | Know what a delete takes with it | **Cascade impact** | | Narrow a list by date | The date chips | | Get every record, not just the first 10 | **Open in SOQL Builder** | | Share the exact query | **Copy SOQL** | This guide describes Related Records in SFDC Police 1.1.13. Reference: [Related Records docs](https://www.sfdcpolice.com/docs/features/related-records). ## What's New: Faster Related Records, Related Queries, a Clearer Access Check, and CG Doctor Source: https://www.sfdcpolice.com/blog/whats-new-november-2026 > Step-by-step guides with real use cases for the newest SFDC Police features — tested end to end on a live Consumer Goods Cloud org. Every feature below comes in version 1.1.13 and was tested end to end on a live Salesforce org (a Consumer Goods Cloud trial) before release. Version 1.1.9 doesn't have them. Each section says what the feature is for, when you would reach for it, and exactly how to use it. ### 1. Related Records: faster, readable, and one click to SOQL Related Records shows everything connected to a record: its parents and every child list. On a large account it now loads about four times faster, names lists the way Salesforce does, filters long lists, and hands any list straight to SOQL Builder. ![Related Records with readable list names, a filter, and Copy SOQL / Open in SOQL Builder](https://www.sfdcpolice.com/blog/whats-new-nov-2026/related-records-names-filter.png) *In the screenshot: 1 filter the lists, 2 open a list (shown by its readable name), 3 Copy SOQL, 4 Open in SOQL Builder.* #### Use cases - **"What would deleting this account take with it?"** Open the account and click **Cascade impact**: the inspector previews what a delete would remove along with it. - **Data clean-up before a migration.** Filter the lists to the objects you are moving (for example "job" or "visit") and check how many child records each account really has. - **Investigating a support ticket.** A customer says a visit or order is missing: open the account, filter to that list, and open the records from there. - **Handing a list to a teammate.** Copy the list's SOQL and paste it into a ticket so they can run exactly what you saw. #### How to use it 1. Open **Related Records** (from SFDC Police's tools, or from the floating panel's **Actions** tab under *Suggested here*) and paste a record Id, or search by name. 2. The record card and its parent lookups appear in about a second. Child lists fill in as their counts arrive; the heading says "still counting…" until the last one. You can open a list while counting continues. 3. With more than five lists, type in **Filter related lists** to narrow them by name, API name or object. 4. Open a list to see its records. Use the date chips (Today, This week, Last 7/30 days) to narrow by created date. 5. Click **Copy SOQL** to copy the list's query, or **Open in SOQL Builder** to run it there over *all* records, not just the 10 shown. ![The list's query opened in SOQL Builder, returning all 27 records](https://www.sfdcpolice.com/blog/whats-new-nov-2026/soql-builder-handoff.png) **Good to know:** hyperlink and image formula fields now show as a link or text instead of raw HTML. Related Records now asks which lists have any records in one query per 20 relationships, then counts only the lists that do. On a large Consumer Goods account the full load went from about 10 seconds to about 2, with fewer API calls. ### 2. Related queries in the floating panel On any record page, the floating panel's **Query** tab can now suggest a query for every object related to that record, so you can pick the one your issue needs instead of writing it. ![Related queries in the panel, filtered to "customer set"](https://www.sfdcpolice.com/blog/whats-new-nov-2026/panel-related-queries.png) *In the screenshot: 1 Related queries, 2 filter, 3 pick a suggestion, 4 Run.* #### Use cases - **Junction lookups without writing a semi-join.** On an Account, "Customer Sets via Customer Set Customers" gives you `SELECT Id, Name FROM cgcloud__Account_Set__c WHERE Id IN (SELECT cgcloud__Account_Set__c FROM cgcloud__Account_Set_Account__c WHERE cgcloud__Account_Set_Account__c = '…')`. On a Customer Set, the same feature lists its Accounts. - **Child records at a glance.** Pick "Visits" or "Job Lists" to query this account's children directly. - **Checking the parent side.** Parent suggestions show the records this one points to (for example its account template), useful when a value seems to come from nowhere. - **Learning the data model.** Browsing the list on an unfamiliar object shows how it connects to everything else. #### How to use it 1. Open the floating panel on a record page and go to **Query**. 2. Click **Related queries**. The panel groups suggestions into *Linked through a junction object*, *Child records* and *Parent records*. 3. Type in **Filter related objects** to narrow a long list (for example "customer set"). 4. Click a suggestion to put it in the editor. Nothing runs until you press **Run**, so you can add fields or filters first. ### 3. Checking a user's access to a record "Why can't my rep see this?" is now a single step. Access X-Ray explains a user's access to the record you are on, layer by layer. Its verdict comes from Salesforce's own record-access answer (`UserRecordAccess`); if that check fails or returns nothing, X-Ray warns that the verdict may be incomplete. ![The record access check: pick a user and Access X-Ray opens with every layer](https://www.sfdcpolice.com/blog/whats-new-nov-2026/panel-access-check.png) *In the screenshot: 1 pick the user, 2 the verdict, 3 each layer that explains it.* #### Use cases - **A rep says a record is missing.** Pick the rep: the verdict shows "No access — record is invisible" and the layers show why (for example a Private org-wide default, no role-hierarchy or sharing-rule grant). - **Someone can see more than they should.** Pick the user: the System Bypass layer names permissions such as View All, and the Object Permissions layer shows where it comes from. - **Before changing sharing.** Check one user who should keep access and one who should not, before and after the change. - **Explaining access in an audit.** Each layer lists the setting and source behind the answer, so you can quote it. #### How to use it 1. Open a record in Salesforce and open the floating panel. 2. Go to **Access → Record**. Under **Check a user's access to this record**, search for the user by name or email and pick them. 3. Access X-Ray opens straight away with the verdict (Read / Edit / Create / Delete) and about ten layers: object permissions, org-wide default, ownership, role hierarchy, sharing rules, system bypass permissions, the record-access verdict, field-level security, page layout and record type access. 4. Open any layer for its details. Use the **✕** in the search box to check another user. To look up a different object's details, use **Look up another object** at the bottom of the same tab. (The screenshot above was taken before that search moved to the bottom.) ### 4. Moving a record to another org (Beam) The floating panel's **Move** tab copies the record you are on into another org you are signed in to. Target orgs are now listed by name, so it is harder to pick the wrong one. ![Move / Beam with target orgs listed by name](https://www.sfdcpolice.com/blog/whats-new-nov-2026/panel-move-beam.png) *In the screenshot: 1 pick the target org, 2 refresh the list of orgs, 3 Analyze move.* #### Use cases - **Reproducing a bug in a sandbox.** Beam the exact record from production so you can test on the same data. - **Seeding a demo or training org** with a few realistic records. - **Copying a record with its parents.** Tick *Include parent hierarchy* so lookups resolve in the target. - **Copying a record with its children.** Tick *Include child records* when you need the full picture. #### How to use it 1. Open the record and the floating panel, then go to **Move**. 2. Under **Move to**, pick the target org. It is shown as "Org name · host"; open the target org in another tab first if it is missing, then press refresh. 3. Choose whether to include the parent hierarchy and child records, then click **Analyze move**. 4. Review the plan: each record, whether it will be created or reused, and how many fields will be copied. A warning appears if the target is a production org. 5. Click **Beam**. The panel reports how many records were created and reused. ### 5. CG Doctor: who should get an activity's job list For Consumer Goods Cloud, CG Doctor explains why something does or doesn't show on a visit. Its new **Job list people** tab answers "did this activity's job list go to the right people?" ![CG Doctor's Job list people tab: each person, whether the rule picks them, and their job list](https://www.sfdcpolice.com/blog/whats-new-nov-2026/cg-doctor-job-list-people.png) *In the screenshot: 1 the visit's rep, 2 whether the rule picks each person, 3 the check that decided the answer, 4 the values it read, by record.* #### Use cases - **A rep says a survey or task is missing from their visit.** Check whether the rep has a job list for that activity on that account. - **An activity went to the wrong people.** See who Salesforce's rule picks (active managers of the right type whose dates overlap the activity, then the User Policy: All, Only Main or First) and who actually holds a job list. - **After changing account managers.** Confirm the job lists followed, or see that they are still as the batch last left them. - **Checking visibility, not just setup.** Every tab also checks whether the visit's rep can read the main records behind the answer (the account and activity, or the promotion and its tactics). #### How to use it 1. Open **CG Doctor** and pick a visit (search by visit number, account or rep, or paste a Visit Id). 2. Choose the tab for your question: **Survey questions**, **Promotions** or **Job list people**. 3. Each item says *Shows*, *Doesn't show* or *Can't tell* (or *Right people*, *Wrong people*, *Can't tell*), with the check that decided it. 4. Expand an item to see every check, the values it read (grouped by record, with names and links), and what would settle anything it can't tell. CG Doctor says **Can't tell** whenever the org's data can't prove the answer, for example where Salesforce doesn't document a rule. It never guesses. ### Try it These features arrive in **SFDC Police 1.1.13**. For the full reference, see the docs for [Related Records](https://www.sfdcpolice.com/docs/features/related-records), the [floating panel tools](https://www.sfdcpolice.com/docs/features/floating-panel) and [CG Doctor](https://www.sfdcpolice.com/docs/features/cg-doctor). Install from the [Chrome Web Store](https://chromewebstore.google.com/detail/pjpcgahadclnombmadpnhpkhlabccdno), where 1.1.13 is now the published version; Chrome updates an installed extension on its own. Check that the extension's version is 1.1.13 or later, because 1.1.9 doesn't have these features. ## How to Find Every God-Mode User in Your Org Source: https://www.sfdcpolice.com/blog/find-god-mode-users > Identify users with dangerous permission combinations before they become a security liability. "God mode" in Salesforce is access that lets a user read or modify nearly everything in the org. It accumulates silently, through profiles and permission sets, and by the time you audit permissions, you might have dozens of users with far more power than their job function needs. Auditing for god-mode access is a critical security task. Here's what you're looking for. ### What "God Mode" Means God-mode users typically have one or more of these permissions: - **Modify All Data** — edit every record in the org, regardless of ownership or sharing rules. - **View All Data** — read every record in the org. - **Customize Application** (and **Modify Metadata Through Metadata API Functions**) — change org configuration (custom fields, validation rules, flows). - **Author Apex** — write and run Apex code. - **Manage Users** — create and modify users. - **Object-level View All / Modify All** — for critical objects like Account or Opportunity, View All / Modify All on the profile or permission set. Any one of these is powerful. In combination, they're dangerous. ### The Accumulation Problem Here's the silent part: a user can accumulate these permissions across multiple places. - Their **profile** might grant View All on the Account object. - An assigned **permission set** might grant Modify All Data. - A **permission set group** they're added to might grant Author Apex. - A **muting permission set** inside that group can switch off a permission the group grants, but it does nothing to the profile or to other permission sets and groups, so the same permission can still come through them. An admin might know the user was assigned a permission set six months ago, but not remember what it grants. The user's role changes, but their old permission sets never get removed. The permission set gets updated to add a new permission, and that change cascades to everyone assigned to it. By the time you audit, the user has six layers of permissions from six different sources, and the cumulative effect is god-mode access. --- ### Toxic Permission Combinations Some combinations are especially dangerous. **Modify All Data + Data Export** A user with Modify All Data can edit records. If they can also export (Export Reports, or Weekly Data Export), they can export every record in the org and walk away with your customer list, financial data, and employee information. **View All Data + API Enabled** A user with View All Data and API access can query every record via REST or SOQL and bulk-download data in minutes. **Customize Application + Author Apex + Manage Users** This user can change any configuration, write and run code that executes in any security context, and create new users. They can create a backdoor. **Modify All Data + Workflow + Process Builder** If this user can also create workflows or flows, they can create automation that modifies or deletes records silently and at scale. The concept is "blast radius" — the scope of damage a compromised account can do. An intern with Modify All Data has a blast radius equal to every record in your org. --- ### Finding God-Mode Users Manually You'd start in Setup: 1. Check every profile for system permissions. 2. Check every assigned permission set. 3. Check every permission set group. 4. Check each of those groups for a muting permission set (it only turns off permissions within its own group). 5. For each object (Account, Opportunity, Contact, etc.), check if there's a View All / Modify All grant. Then you'd cross-reference: who has Modify All Data? Who has View All Data? Whose cumulative permissions cross into toxic territory? This is a half-day audit for a 100-user org. It's error-prone and hard to automate manually. --- ### The Automated Way: Security Insights SFDC Police's **Security Insights** module surfaces god-mode users and toxic permission combinations. It reads your org's users, profiles and permission sets and identifies: - **Powerful permissions** — who has Modify All Data, View All Data, Customize Application, Author Apex, or Manage Users. - **Toxic combinations** — users whose stacked permissions match a risky pattern (e.g., View All Data + Run Reports, or Manage Users + Author Apex). - **Object-level View All / Modify All** — who has View All or Modify All on an object such as Account. For each user, it shows the exact source of each permission (which profile or permission set), so you can audit and remove permissions without guessing. It also gives an overall security posture score, a weighted average of six dimensions such as permission hygiene, least privilege, access cleanup and login security. --- ### Reducing Blast Radius Once you've identified god-mode users, the fix is straightforward: 1. **Inventory their current permissions** — use Explain Access (Permission Intelligence in 1.1.13) or Persona Simulator to see the full stack. 2. **Ask: what does their job require?** — A support agent probably needs read access to Cases and Knowledge Articles, not Modify All Data. 3. **Build focused permission sets** — create permission sets that grant only the objects and actions they need (e.g., "Support Agent" grants Read/Create/Update on Case, Read on Knowledge). 4. **Remove the broad permissions** — replace the high-blast-radius permission set with smaller, more specific ones. 5. **Validate before and after** — use Persona Simulator to confirm they can still do their job with the new permissions. For most users, god-mode permissions are technical debt, not necessity. An admin needs Customize Application and Author Apex. A support agent doesn't need Modify All Data. A financial analyst needs View All Data for reports, but not Modify All Data. --- ### Starting Your Audit Run your first god-mode audit from Security Insights. See the [Security Insights feature documentation](https://www.sfdcpolice.com/docs/features/security-insights) to get started. No setup required — it runs on your existing Salesforce session and analyzes permissions as they are right now. For a guided walkthrough on moving away from god-mode profiles toward specific permission sets, read [Profiles Are Fading: A Practical Move to Permission Sets](https://www.sfdcpolice.com/blog/profiles-to-permission-sets). ## Profiles Are Fading: A Practical Move to Permission Sets Source: https://www.sfdcpolice.com/blog/profiles-to-permission-sets > Salesforce is steering away from profile-based permissions toward permission sets. Here's how to migrate safely. Salesforce has been quietly repositioning profiles for years. The message is clear now: profiles are a baseline. The future is permission sets and permission set groups. The shift makes sense. Profiles are monolithic. If two users have the same job but one needs an extra feature, they can't share a profile — you have to clone it, modify it, and maintain two profiles forever. Permission sets are modular. You stack them on top of a baseline profile. Sales Role gets Salesforce CRM Base, then add Sales Cloud Features, then add Forecasting, then add Einstein Analytics. Three permission sets, one profile. It's also where Salesforce is investing. New features often only appear in permission sets, not profiles. If you want to grant Assign Permission Sets, Create Apps, or API Limits, you're assigning permission sets, not editing profiles. If your org still runs on profiles, the migration is inevitable. Here's how to do it safely. --- ### The Permission Model: Profile + Permission Sets + Permission Set Groups + Muting PS A user's effective permissions are the sum of four sources: - **Profile** — The baseline. Every user must have a profile. It grants the foundational permissions for their role (standard object CRUD, basic features). - **Permission Sets** — Feature-based add-ons. You stack these on top of the profile to grant specific capabilities (Forecasting, Content, API access). One permission set = one feature. - **Permission Set Groups** — Bundles of permission sets. Instead of assigning ten permission sets individually, you assign one permission set group that contains those ten. It's a convenience layer. - **Muting Permission Sets** — A muting permission set lives inside a permission set group and turns off chosen permissions that the group's own permission sets grant. You can't assign one to a user, and it only mutes within its group: if the profile, another permission set or another group grants the same permission, the user keeps it. To mute Modify All Data in a group, you enable Modify All Data in that group's muting permission set. Most orgs run on just profile + permission sets. Permission set groups make sense if you have large stacks (10+ permission sets per user). --- ### Migration Strategy: Phase by Phase **Phase 1: Inventory Current Profile Permissions** Audit your existing profiles. For each profile, document: - System permissions (Create Users, Author Apex, Modify All Data, etc.). - Object-level CRUD and View All / Modify All. - Tab visibility (standard and custom). - Admin or custom user license type. Export this to a spreadsheet. You'll use it to group users by job function. **Phase 2: Group Permissions by Job Function** Look at your profiles and user base. If you have a "Sales User" profile and 60 users on it, they don't all have identical needs. Some need Forecasting. Some need Territory Management. Some need Einstein Analytics. Create job function groups: - Sales Rep (standard Salesforce CRM Base) - Sales Manager (+ Forecasting, + Reports, + Dashboards) - Sales Engineer (+ Forecasting, + Knowledge, + Contracts) - Support Agent (+ Cases, + Knowledge, + Chat) - Admin (+ Customize Application, + Manage Users, + Author Apex) For each group, document the permissions they actually need. **Phase 3: Build Feature-Based Permission Sets** Create permission sets, not by role, but by feature: - "Salesforce CRM Base" — Read/Create/Update on Accounts, Contacts, Opportunities, Tasks, Events (this replicates what the profile grants). - "Forecasting" — Forecast object CRUD, Forecast Namespace API. - "Reports and Dashboards" — Report and Dashboard CRUD, folder access. - "Einstein Analytics" — Analytics Cloud API, Insight object access. - "API Access" — API Enabled permission. One permission set = one feature. This makes it easy to audit and update — if the Forecasting permission set is broken, you fix one place, not ten profiles. **Phase 4: Validate Effective Access** Before you cut over any users, validate that their new permission stack grants the same access as their old profile. This is where **Persona Simulator** is essential. For a test user, assign them the new permission set stack (keep the profile they're on, remove the old profile's extra permissions, add the permission sets). Then run Persona Simulator and compare: - Same objects readable and writable? - Same fields readable and editable? - Same tabs visible? Persona Simulator doesn't cover system permissions or record-level access. Check system permissions separately, and check record access with Access X-Ray in the floating panel. Persona Simulator shows you the effective access — Profile + all assigned Permission Sets + all assigned Permission Set Groups + all assigned Muting Permission Sets resolved into one verdict. If it matches the old profile, you're safe to migrate the user. **Phase 5: Migrate Users and Retire Old Profiles** Roll out in waves: - Week 1: Admins (easiest, smallest group, can help if something breaks). - Week 2: Power users (developers, process builders, flow authors). - Week 3: Standard users (largest group, most risk, most testing done by now). - Week 4: Contractors, partners, and API integrations. For each wave, assign the new permission set group or stack, validate in Persona Simulator that access is identical, and monitor for a week. If everything is stable, remove the old profile assignment. Once all users are migrated off a profile, retire it. Don't delete it — archive it or mark it obsolete. You might need it as a reference. --- ### Tools That Make This Safe **Permission Builder** Permission Builder is a visual, dependency-aware tool for building permission sets. Instead of clicking through Setup's cryptic checkboxes, you: - Select objects you want to grant access to. - Click which permissions you need (Create, Read, Update, Delete, View All, Modify All). - See object dependencies visualized as a graph (if your permission set grants Opportunity, the graph shows Account as a parent dependency and Opportunity Teams as a related dependency). - Preview the permission set before you save it. - Load an existing permission set and extend it. It helps prevent mistakes (like forgetting to grant Read access to Accounts when you grant Create access to Opportunities). **Persona Simulator** Persona Simulator is how you validate effective access before and after migration. For any mix of profile, permission set groups and permission sets, it builds a combined view: - Their profile's CRUD matrix. - Every assigned permission set's CRUD matrix. - Every permission set group's stacked permissions. - Every muting permission set's subtractions. It shows you the combined effect — the objects and fields they can read and write, and the tabs and apps they get. If the profile-based version and the permission-set-based version show the same effective access in Persona Simulator, you're safe to migrate. It also lets you experiment: add a test permission set to the persona and see how the combined access changes. --- ### Post-Migration: The Permission Set Maintenance Strategy After migration, you'll need ongoing maintenance. Every time you need to grant a new feature to a user: - Check if a permission set for that feature exists. Assign it. - If not, create one. Build it modularly so other users can reuse it. - Don't clone profiles and modify them. Don't create one-off permission sets. Maintain a small library of features and reuse. Over time, you'll have 30–50 permission sets, organized by feature, that cover every capability in your org. New users and features are additive. You don't maintain 100 profiles. You maintain 50 permission sets that are reassigned and recombined. It's a cleaner, more maintainable model. It's also where Salesforce is heading. --- ### Getting Started Use **Permission Builder** to design your permission sets, and **Persona Simulator** to validate that effective access is preserved during migration. See [Permission Builder](https://www.sfdcpolice.com/docs/features/permission-builder) and [Persona Simulator](https://www.sfdcpolice.com/docs/features/persona-simulator) for detailed walkthroughs. For a deep dive on the 10 layers of access that permission sets control, read [The 10 Layers of Salesforce Record Access](https://www.sfdcpolice.com/blog/ten-layers-of-record-access). ## The 10 Layers of Salesforce Record Access Source: https://www.sfdcpolice.com/blog/ten-layers-of-record-access > How Salesforce resolves whether a user can see and edit a record, from object permissions through system admin bypasses. When a user clicks on a record in Salesforce, the platform makes an instant decision: can this user view it? Can they edit it? That decision isn't simple. It's the result of ten sequential checks, each one capable of granting or blocking access. Understanding these layers is the difference between a permission setup that works and one that leaks data or locks out legitimate users. ### Layer 1: Object Permissions The first gate is the object permission itself. If a user's profile or permission set doesn't grant Create, Read, Update, or Delete on the object, the record is invisible. But there's a wrinkle: a permission set can flip View All or Modify All on an object. View All Data grants read access to every record of that object, regardless of ownership or sharing. Modify All Data grants full edit access. These system permissions bypass all nine of the sharing rules that come next. ### Layer 2: Org-Wide Defaults Org-Wide Defaults (OWDs) set the baseline sharing posture for each object. The options are Private, Public Read Only, Public Read/Write, and Controlled by Parent. If the OWD is Private, a user can see only records they own or that have been explicitly shared with them. If it's Public Read/Write, every user in the org can see and edit every record on that object — and the remaining sharing layers just tighten access further, they never broaden it. ### Layer 3: Record Ownership If the user owns the record, they can see and edit it (unless the OWD is Private and their role doesn't grant access through other means). Ownership is explicit: the Owner field on the record. ### Layer 4: Role Hierarchy Role hierarchy grants implicit sharing "up the ladder." If User A reports to User B, User B can see all of User A's records by default (unless the OWD is Private and the role hierarchy sharing is disabled, or unless the record is shared only downward). This is often the first sharing rule admins forget about — it's silent and powerful. ### Layer 5: Sharing Rules Sharing rules come in two flavors: owner-based and criteria-based. Owner-based rules grant access to all records owned by a specific user or role. Criteria-based rules grant access to records that match a condition. These rules always broaden access; they never restrict it. If the OWD is Private and no sharing rule applies to the user, they don't see the record. ### Layer 6: Account Teams, Opportunity Teams, and Case Teams Teams are a lightweight alternative to sharing rules. If a record has a team associated with it and the user is on that team, they get the access level assigned to their team role. ### Layer 7: Manual Shares A record owner can manually grant access to the record to a specific user or group. This is one-off sharing, not rule-based. ### Layer 8: Implicit and Built-In Sharing Some objects implicitly share records based on parent-child relationships. If you have read access to a parent record, you can often read its child records. The details depend on the object model. ### Layer 9: Territory Management Territory management is an overlay for Accounts, Opportunities, and related objects. If you own a territory or are assigned to one, you can see and potentially edit records in that territory. ### Layer 10: System Permissions Finally, system permissions like Modify All Data and View All Data act as a master key. If a user has View All Data, they see every record, period. If they have Modify All Data, they can edit every record. These permissions are often granted to admins, but they accumulate through profiles, permission sets, and permission set groups. Finding every user with these permissions is a critical security audit — and surprisingly hard to do manually. --- ### Beyond Record Access: The Final Gates Even after passing all ten layers, a user still faces two more barriers to actually seeing and editing a record. **Field-Level Security** (FLS) controls which fields are visible and writable. You might have full edit access to a record, but FLS can hide the Salary field or make it read-only. **Page Layout and Record Type** assignment control which fields appear on the detail page and which relate to which record type. A user might have access to the record but not see all the fields because their page layout excludes them. --- ### The Access X-Ray Shortcut Tracing these ten layers manually is tedious. You'd need to check the user's profile, all assigned permission sets, the OWD, the role hierarchy, sharing rules, teams, manual shares, territory assignments, and system permissions. SFDC Police's **Access X-Ray** breaks this down layer by layer. Open it on a record, pick a user, and it checks ten layers: object permissions, org-wide default, ownership, role hierarchy, sharing rules, system bypass permissions, Salesforce's own record-access verdict, field-level security, page layout and effective visibility. For each step it says whether the user passes or is blocked, and why. No setup required, no API keys, and nothing is sent anywhere but Salesforce. From there, you can open Explain Access (called Permission Intelligence in version 1.1.13) to trace the full permission source (which profile or permission set?) and see why a user has, or lacks, a given permission. See the [features](https://www.sfdcpolice.com/features) page to get started, or read [Why Can This User See This Record?](https://www.sfdcpolice.com/blog/why-can-this-user-see-this-record) for a practical walkthrough. ## Why Can This User See This Record? Source: https://www.sfdcpolice.com/blog/why-can-this-user-see-this-record > The #1 question an admin gets — and why answering it by hand means clicking through dozens of Setup pages. Here is the fast way. It is the most common ticket in any admin's queue: "Why can this person see this record?" or its evil twin, "Why *can't* they?" The question sounds simple. Answering it is not, because access in Salesforce can originate from almost anywhere. ### Why it is hard A single user's access to a single record can come from any of these, alone or in combination: - their **profile** (object permissions, View All / Modify All, View All Data / Modify All Data) - any number of assigned **permission sets** - a **permission set group** they belong to - a **muting permission set** that subtracts from a group - record **ownership** - the **role hierarchy** rolling access upward - **sharing rules** (owner-based or criteria-based) - **account, opportunity, or case teams** - a one-off **manual share** - **implicit** parent-child sharing you cannot turn off To answer the question manually, you open the user, read their profile, open every permission set, open every group, check ownership, walk the role hierarchy, scan the sharing rules, and finally open the record's sharing detail. For a real org this is twenty minutes of clicking — per question. (For the full breakdown of these layers, see [The 10 layers of record access](https://www.sfdcpolice.com/blog/ten-layers-of-record-access).) ### The manual trace If you do it by hand, work top-down and stop at the first thing that grants access: 1. Does the profile or a permission set carry **View All Data** or object **View All**? If yes, you are done — sharing is irrelevant. 2. Does the user **own** the record, or sit above the owner in the **role hierarchy**? 3. Is there a **sharing rule** that puts the record in front of the user's role or a group they are in? 4. Is the user on a **team** for the parent record, or is there a **manual share**? 5. Is access **implicit** through a parent the user can already see? The trouble is that each of those checks is a different Setup screen, and "the first thing that grants access" is exactly what you do not know going in. ### The answer, with its source This is why SFDC Police has **Access X-Ray** and **Explain Access**. Point Access X-Ray at a user and a record, or Explain Access at a user and a permission, and you get the answer with the *source* attached: - **Access X-Ray**, in the floating panel on a record page, checks one record for one user layer by layer: object permissions, org-wide default, ownership, role hierarchy, sharing rules, View All / Modify All, Salesforce's own record-access verdict, field-level security, page layout and effective visibility. - **Explain Access** returns a verdict — Granted or Denied — and the exact grant path. Not "they probably have a sharing rule," but "Granted via the `Modify All Data` system permission on the System Administrator profile." - **Explain Access → Trace** (called Permission Intelligence in version 1.1.13) traces a permission back through the full dependency stack — Profile, Permission Sets, Permission Set Groups, and Muting Permission Sets — with source tracking at every step, so you see which assignment is responsible. From there you can go further: - **Who Has Access** runs the question in reverse: instead of "why can this user see this," ask "*which* users can see this field or object?" and get the list. - **Compare Users** puts two users side by side and highlights exactly where their effective access differs, with export to CSV, JSON, TSV, or the clipboard for audit evidence. ### Why source tracking matters Knowing that access exists is half the answer. Knowing *where it comes from* is the half that lets you act. If a user can see a record through a sharing rule, you fix the sharing rule. If it is a stale permission set from a role they left a year ago, you remove the assignment. If it is View All Data they never should have had, that is a security finding, not a sharing tweak. Without source tracking, every fix is a guess. With it, "why can this user see this record?" goes from a long investigation to a single, citable answer. Read the [Explain Access documentation](https://www.sfdcpolice.com/docs/features/permission-chain), or see the [features page](https://www.sfdcpolice.com/features) for Access X-Ray and the other access tools. ## Why Change Sets Fail, and How to Move the Records They Can't Source: https://www.sfdcpolice.com/blog/why-change-sets-fail > The real reasons change sets are painful: dependencies you add by hand, no rollback, slow validation, no data. What to use for metadata, and what to use for records. Change Sets are Salesforce's built-in tool for moving customizations between orgs. They're also one of the most frustrating things a Salesforce admin does regularly. Validation fails with an error that doesn't point at the real problem. There is no undo. To fix the change set you clone it and start again. Days pass. Here's why. ### The Change Set Pain Points **Dependencies You Add by Hand** Change Sets have a **View/Add Dependencies** button, but it doesn't catch everything, and you still pick and add each component yourself. If Custom Object A has a lookup to Custom Object B and you leave B out, validation fails in the target org. Tracking dependencies by hand is fine for five items and painful for fifty. **No Rollback** Once a Change Set deploys, it's done. If something breaks in production, there is no undo button. You build a new change set that reverses the changes, deploy that, and hope nothing else broke. **Slow Validation** Validating a change set in production runs Apex tests, which can take a long time in a large org. The errors you get back don't always point to the real problem. If validation fails, you clone the change set, fix it, upload it again and wait again. **No Diff Against the Target** A change set lists its components, but it doesn't show what each one will change in the target org. You find out what a field or rule looked like before only after it has been overwritten. **Can't Move Data** Change Sets move metadata only. If you need to copy records (accounts, products, price books, reference data), you need Data Loader or another process, and you have to work out the load order and the record IDs yourself. **Clumsy Reuse** Once uploaded, a change set is locked. To change it, you clone it and edit the clone. Keeping several orgs in step means a trail of near-identical change sets. **Easy to Miss Components** In large deployments, it's easy to forget that Custom Field X references Custom Object Y, or that a Validation Rule depends on a Formula Field. Change Sets don't enforce this discipline. --- ### Alternatives for Metadata **Salesforce CLI and Source Format** The modern way to move metadata is the Salesforce CLI (`sf`), working with source code in Git. You retrieve metadata from an org into a repo, commit it, and deploy it to another org. It supports more metadata types than Change Sets, and Git shows you exactly what changed. Rolling back means reverting in Git and deploying again, sometimes with a destructive-changes manifest for components you added. The learning curve is steep if you're not comfortable with Git and the command line. Scratch orgs and packaging also need a Dev Hub. For a one-off deployment, it can feel like overkill. **Unlocked Packages** Unlocked packages bundle and version metadata. You create package versions with the Salesforce CLI against a Dev Hub and install them in other orgs. The setup takes work: you manage versions and package dependencies. For admins who just need to move a few custom fields, it's a lot of machinery. Both are standard in mature DevOps teams. Both are a lot to learn for an admin with a weekend deployment window. --- ### The Part None of These Move: Records Change Sets, the CLI and packages all move metadata. None of them copies records. Seeding a sandbox, promoting reference data, or keeping two orgs' data in step is a separate job, and it is the job SFDC Police's **Data Migrator** is built for. Data Migrator copies **records** between orgs. It does not deploy metadata: the objects and fields must already exist in the target, so move them first with a change set, the CLI or a package. Before a run it compares the two orgs' schemas and checks your permission sets, so you find a missing field before you write anything. **Parent-First Load Order** It orders the objects you pick from their relationships, so parents load before their children, and it remaps lookups between the records it migrates. No hand-built load order. **A Dry Run Before Any Write** Before writing, a dry run shows the record count per object, the order the objects will load in, and the conflicts it can see coming: duplicate external IDs in the target, lookups to records outside the run, and picklist values the target doesn't allow. It also estimates the API calls the run will use. You read it, then decide. **Four Modes** You choose how the target is treated: **Seed** inserts new records, **Promote** creates or updates records, **Repair** updates records that are already there, and **Mirror** creates or updates records and, for the objects you opt in, deletes target records that aren't in the source. **Matching Between Unrelated Orgs** Related orgs (a production org and its sandbox) can match on record Id. Between unrelated orgs, you choose the key: an external ID field, or a natural key you pick, such as account name plus billing country. When a record already exists in the target but differs, it is reported as drifted, and you choose whether to update it. **Rollback with Before-State Snapshots** Rollback deletes the records a run inserted and patches updated records back to the values it snapshotted before the write. You confirm it before it runs. From version 1.1.13, a lookup patched after the main load is applied only once its original value is snapshotted. **Checkpoint Resume** Progress is saved as the run goes, so a run interrupted by a closed browser can resume from the last checkpoint. **Preflight Checks** Preflight looks for common edge cases, such as encrypted fields, duplicate rules, polymorphic lookups, person accounts and multi-currency, and tells you what each one means for the run. --- ### Which Tool for Which Job Use **Data Migrator** if: - You need to copy records between orgs, in dependency order. - You want a dry run before writing and a way to roll back. - You're moving records between unrelated orgs and need to match on your own key. Use **Salesforce CLI** if: - You're in a DevOps team with Git and CI/CD. - You're deploying metadata from source control. - You need to version and audit every change. Use **Change Sets** if: - You're moving a small number of components between related orgs and prefer the Setup UI. --- ### Getting Started See the [Data Migrator feature documentation](https://www.sfdcpolice.com/docs/features/data-migrator) for a step-by-step walkthrough. No setup required: Data Migrator runs on your existing Salesforce session and reads and writes through Salesforce's APIs (REST and Bulk). For more, read [Migrating Orgs Safely](https://www.sfdcpolice.com/docs/guides/migrating-orgs-safely) or explore the [features page](https://www.sfdcpolice.com/features). ## Getting Started with SFDC Police Source: https://www.sfdcpolice.com/blog/getting-started > A quick guide to installing and configuring the SFDC Police Chrome extension for your Salesforce org. Welcome to SFDC Police — the admin toolkit that makes Salesforce permissions, data exploration, and org management actually enjoyable. ### Installation 1. Visit the Chrome Web Store and search for "SFDC Police" 2. Click **Add to Chrome** 3. That's it — no configuration needed ### Connecting to Your Org Once installed, simply navigate to any Salesforce page. The extension automatically detects your org and connects using your existing browser session. No API keys, no connected apps, no admin approval needed. ### Your First Steps #### Open the panel On any Salesforce page, click the SFDC Police icon in Chrome's toolbar. A panel opens on the page with tools for what you're looking at: on a record, for example, who can see it and its related records. #### Open a tool In the panel's **Actions** tab, pick a tool, or open **All tools** to see every one. Each tool opens in its own tab, on the same org. #### Build a query Open **SOQL Builder** to pick an object and fields, run the query and export the results. #### Compare permissions Open **Permission Matrix** (called Data Dictionary, under Permissions, in versions up to 1.1.13), pick a few profiles and permission sets, and click **Generate** to see their object, field and tab access side by side. ### Need Help? Check the [documentation](https://www.sfdcpolice.com/docs) for a guide to each feature. ## The Complete Guide to Salesforce Permission Management Source: https://www.sfdcpolice.com/blog/permission-management-guide > Learn best practices for managing permissions in Salesforce, from profiles to permission sets to permission set groups. Permission management in Salesforce can feel like navigating a maze. With profiles, permission sets, permission set groups, and field-level security all playing a role, it's easy to get lost. Here's how to stay in control. ### The Permission Hierarchy Understanding how Salesforce evaluates permissions is critical: 1. **Profile** — The baseline. Every user has exactly one profile. 2. **Permission Sets** — Additive layers on top of the profile. 3. **Permission Set Groups** — Bundles of permission sets for easier management. Permissions are always additive — you can grant access but never revoke it through permission sets. ### Best Practices #### Use Permission Sets Over Profiles Salesforce recommends the "minimum access profile" approach: - Create profiles with minimal permissions - Use permission sets to grant specific access - Group related permission sets into permission set groups #### Name Conventions Matter Use a consistent naming convention: - `PS_Sales_ReadAccounts` — Permission set for sales to read accounts - `PSG_SalesTeam` — Permission set group for the sales team #### Regular Audits Review permissions quarterly to: - Remove unused permission sets - Identify over-provisioned users - Check for permission drift between environments ### How SFDC Police Helps SFDC Police's permission tools let you: - Compare two permission sets, or two users, side by side (Compare; PS Comparison in 1.1.13) - See the combined access of a profile and its permission sets, with the source of each permission (Persona Simulator) - Build new permission sets step by step, with dependency checks (Permission Builder) - Assign and remove permission sets, with rollback (Access Editor) Stop guessing about permissions. Start seeing them clearly.