How to use Salesforce Inspector Reloaded 2.0: New Features You Should Be Using
Introduction
Salesforce Inspector Reloaded is a free, open-source browser extension that has become essential for Salesforce admins and developers who need to speed up data work, troubleshooting, and metadata visibility. Rather than clicking through endless Setup menus, you can open Salesforce Inspector directly from any record page to inspect fields, run SOQL queries, export data, and diagnose automation issues in seconds
In large or complex Salesforce orgs, tools like this matter more than you might expect. When you’re managing multiple sandboxes, heavy integrations, dozens of custom objects, and layers of automation, the standard Salesforce UI can feel painfully slow. Every click through Object Manager, every scroll through field lists, every tab switch to Developer Console, it adds up. Admins working across multiple orgs daily can lose hours to context switching alone.
Version 2.0 of Salesforce Inspector Reloaded introduces significant upgrades that address real pain points. The standout addition is Flow Scanner, a dedicated feature for analysing Salesforce Flow metadata to identify issues before they cause incidents. Enhanced metadata visibility makes it faster to inspect object and field information directly from records. UI and performance improvements round out the release, making the extension snappier and more intuitive for power users.
This article serves as a practical guide on how to use Salesforce Inspector Reloaded 2.0 for real-world admin tasks. Consider a scenario: it’s Friday afternoon, and support tickets are flooding in because Opportunity updates are failing in production. The error message mentions a Flow, but which one? With SF Inspector open, you can inspect the failing record, check related objects, jump to the problematic Flow, and run Flow Scanner to identify issues, all without leaving the browser or opening a new tab or a new window in Setup.
What Is Salesforce Inspector Reloaded?
Salesforce Inspector Reloaded is a modern reboot of the original Salesforce Inspector Chrome extension, maintained by Thomas Prouvot and an active development team on GitHub. Available for Chrome and Edge via the Chrome Web Store, it adds a pop-up UI with Object, Org, and User tab functionality, as well as deeper Flow support than its predecessor. The original version laid the groundwork; this new version builds on it, adding features that align with how Salesforce orgs have evolved.
For Salesforce admins, the core use cases include:
Show all data on a record: View every field value, including those hidden from page layouts
Run SOQL queries: Execute queries directly and export results as a CSV file
Export and import data: Use the data export option for quick extracts, or import data for bulk updates
Inspect metadata: Check field metadata, API name values, data types, and relationships
Jump to Setup pages: Use the shortcut tab to navigate directly to validation rules, page layouts, or Flow Builder
Check org limits: Monitor API limits and API requests from the org tab
Developers benefit equally. You can quickly check field metadata and inspect API names without opening Object Manager. Debug automation issues by reviewing Apex logs via the enable logs feature. Analyse flow structures and flow versions before making changes. The recently viewed records feature helps you navigate back to records you’ve been investigating.
The extension overlays the standard Salesforce UI via an icon or keyboard shortcut. There’s no managed package to install, no extra configuration required, and no sandbox banner confusion. It works the same in production and sandboxes. To install Salesforce Inspector, simply add it from the Chrome Web Store, and you’re ready to use Salesforce Inspector within minutes.
How does this differ from native Salesforce tools? The setup and Object Manager require multiple clicks to reach field information. Flow Builder is excellent for editing, but cumbersome for quick inspections. Developer Console handles debug logs but feels disconnected from record context. Salesforce Inspector Reloaded reduces clicks and context switching without replacing governance processes. It’s a quick-access tool that complements official admin capabilities.
The extension relies entirely on the logged-in user’s Salesforce permissions and uses normal Salesforce APIs under the hood. If you can see a field in Salesforce, you can see it in the extension. If you can run a query in Developer Console, you can run it here. The connected app authentication uses Salesforce’s default connected app, so there’s no separate credential management.
What’s New in Salesforce Inspector Reloaded 2.0
Version 2.0 represents a significant step forward for Salesforce Inspector Reloaded. The release focuses on three areas that matter most to busy admins: Flow Scanner for automation governance, better metadata visibility in the pop-up, and performance refinements that reduce friction when working across other orgs.
If you’re still using an older version of SIR or the legacy Salesforce Inspector, these capabilities warrant attention when you upgrade. The new features address problems that have grown more pressing as Salesforce Flow has become the primary automation tool in the Salesforce ecosystem.
Flow Scanner
Flow Scanner is a dedicated button feature that scans Salesforce Flow metadata in your org to detect patterns, risks, and potential issues across active and draft flows. Rather than manually reviewing each Flow in Flow Builder, you get an aggregated view of problems that need attention.
At a high level, Flow Scanner analyses flow elements such as Decision nodes, Update Records actions, Get Records queries, Subflow references, and more. It examines configuration details, including entry conditions, fault paths, version activation status, and element complexity. The tool parses this metadata to surface issues that would otherwise require tedious manual review.
The types of issues Flow Scanner surfaces include:
| Issue Type | Description | Risk Level |
|---|---|---|
| Hard-coded IDs | Record IDs or User IDs embedded directly in Flow logic | High – breaks across sandboxes |
| Missing fault paths | Error handling not configured for data operations | Medium – silent failures |
| Recursive triggers | Flows that call themselves or create circular updates | High – governor limit hits |
| Complex decision logic | Excessive branching that’s difficult to maintain | Medium – technical debt |
| Unused elements | Variables or assignments that serve no purpose | Low – metadata bloat |
To use Flow Scanner, open Salesforce Inspector from any page in your org. Navigate to the metadata search or Flow-specific option. Run the scanner against a specific Flow API name or scan the entire org. Review the results table, which shows each issue, the affected Flow, and recommendations.
This capability helps reduce technical debt by identifying flows that should be refactored into subflows, deactivated entirely, or consolidated with other automation. It’s particularly valuable during quarterly reviews or before major releases.
Enhanced Metadata Visibility
Version 2.0 improves how quickly you can view object and field metadata from any record page. When you open Salesforce Inspector and select “Show all data,” you see comprehensive field information, including API names, data types, required and unique flags, help text, and usage indicators where available.
The metadata search now works hand-in-hand with the data display. From a field on a record, you can jump directly to its definition in Setup or view related objects and field relationships in the popup. This integration means less switching between browser tabs and Setup screens.
Consider a typical troubleshooting scenario. An admin receives a report that a Contact record is displaying an error on save. Opening the record and using “Show all data” reveals a formula field that references an inactive picklist value. Without the extension, finding this would require opening Object Manager, locating the formula field among dozens of fields, reviewing its definition, and then cross-referencing picklist values. With Salesforce Inspector, it takes seconds.
This metadata visibility dramatically shortens diagnosis time. You can search for fields by label, API name, or help text, something the native Fields & Relationships view in Setup doesn’t support with the same granularity.
UI and Performance Improvements
The updated popup layout organises functionality into clear tabs: Object, Data (for query, import, export functions), Org, User, and Shortcuts. Commonly used tools surface at the top, reducing the clicks needed to reach them. The user record inspection is easier to access, and the export data option is more prominent.
Specific performance gains include:
Faster loading of object lists, even in orgs with hundreds of custom objects
Cached API results that reduce repeated describe calls
Smoother navigation between tabs without full page refreshes
Quicker saved query retrieval for frequently used SOQL queries
Quality-of-life changes make daily use more pleasant. You can configure a default tab to open first, hide rarely used buttons, and benefit from clearer icons for actions like “Show all data” and “Data Export.” Bug fixes from user feedback address edge cases that caused issues in earlier releases.
These changes particularly benefit admins who work across multiple Salesforce orgs daily. Keyboard shortcuts let you open Salesforce Inspector, run a query, and return to your work without touching the mouse.
Why Flow Scanner Matters for Modern Salesforce Orgs
Salesforce Flow has become the primary automation tool in the platform. With Workflow Rules deprecated and Process Builder on a sunset path (targeted around 2025), organisations have migrated automation wholesale into Flow. This consolidation makes sense architecturally, but it creates a new challenge: Flow sprawl.
Flow sprawl occurs when dozens or hundreds of record-triggered flows, subflows, and screen flows accumulate across core objects such as Account, Contact, Opportunity, and Case. Without active governance, orgs end up with multiple flows on the same object, conflicting entry criteria, and no clear documentation of what fires when.
Flow Scanner helps manage specific risks:
Hard-coded record IDs: Flows built in sandboxes often contain sandbox-specific IDs that break when deployed to production or other orgs
Multiple before/after triggers: Several record-triggered flows on the same object firing on the same event can cause unpredictable order-of-execution issues
Recursive flows: Automation that updates a record, triggering itself to run again, potentially hitting governor limits
Unused or inactive versions: Old flow versions left in the org consume metadata and complicate audits
Performance concerns also warrant attention. Poorly designed flows can run too many SOQL queries (the low-code equivalent of loops), write records in inefficient batches, or cascade into other automation. A single Opportunity update might trigger flows on Opportunity, Account, Contact, and related objects, each of which can add to CPU time and query limits.
Flow Scanner provides a governance view for admins and architects. Rather than reviewing flows one by one in Flow Builder, you get visibility across the entire org. This makes it easier to standardise patterns, document entry criteria, and move toward a “one flow per object per context” approach that many architects recommend.
Use Flow Scanner findings as input for technical debt cleanup projects. Share results with development teams to prioritise refactoring. Include scans in your release planning to catch issues before they reach production.
Practical Use Cases for Salesforce Admins
This section covers the core of using Salesforce Inspector Reloaded for everyday admin work. Rather than theory, these are concrete scenarios you might face this week.
Each example shows how SIR 2.0 speeds up work compared to relying solely on native Salesforce screens. The time savings compound what might take twenty minutes in Setup takes two minutes with the extension.
Diagnosing Broken Automation
Scenario: Immediately after a deployment, Opportunity updates start failing with an error referencing a record-triggered flow. Support tickets are piling up.
Here’s how an admin uses Salesforce Inspector to diagnose the issue:
Log into the affected org (sandbox or production)
Open a failing Opportunity record
Click the Salesforce Inspector icon or use the keyboard shortcut to open the popup
Use “Show all data” to inspect all field values on the record, including those not on the page layout
Check field values involved in the error message, look for null values, invalid references, or unexpected data
Use the shortcut tab to jump directly to the relevant Flow in Setup
With Flow Scanner, take additional steps:
Run Flow Scanner against the problematic Opportunity-related flows
Review results for missing null checks, circular updates to related objects, or hard-coded references
Compare flow versions to identify what changed in the recent deployment
The extension lets you quickly review multiple flow versions, compare which version is active, and collect metadata before making any changes in Flow Builder. You can select id values and trace relationships without opening multiple Setup tabs.
Capture a screenshot or notes directly from SIR’s results to share with the development team or release manager. This creates an artifact for incident documentation.
Reviewing Metadata Before Deployment
Before promoting a change set or DevOps pipeline, verify that new custom fields are created correctly in a staging sandbox.
Pre-deployment verification with Salesforce Inspector:
Open a sample record of the affected object type
Use “Show all data” to confirm new fields (e.g., Discount_Reasonc, Onboarding_Stagec) appear with correct values
Verify API names match what the deployment expects, catching typos before they cause errors
Confirm data types and required flags match the design specifications
Check that formula field calculations return expected results
Use the metadata search or Object tab to quickly check related elements:
Validation rules that might conflict with new field requirements
Record types that should include the new fields
Permission set assignments that grant field access
Page layouts where fields should appear
The org tab lets you check API versions and current org limits before triggering heavy deployments or data loads. If you’re approaching API limits, you’ll know before the deployment fails halfway through.
Supporting Data Quality Audits
Scenario: A quarterly data quality review on Account and Contact records, focusing on key fields like Industry, Rating, and GDPR consent fields.
Salesforce Inspector’s Data Export and SOQL editor make this work efficient:
Open the Data tab in Salesforce Inspector
Write a targeted query: SELECT Id, Name, Industry FROM Account WHERE Industry = NULL
Execute the query and review results inline
Export as CSV file for further analysis or reporting
Save the query as a saved query for reuse next quarter
Field usage analysis, where available, helps identify underused custom fields. If a field shows population rates below 5%, it may be a candidate for deprecation or cleanup to reduce metadata bloat and simplify the user interface.
The “Show all data” feature supports spot-checks of individual records. You can reveal hidden or system fields that influence reporting and segmentation, catching issues that standard reports might miss. Users might not realise a field exists if it’s not on their page layout, but it could still drive automation or integration logic.
Document audit findings, then use native Salesforce tools or change management processes to update picklists, validation rules, or automation as needed.
Inspector Reloaded vs Native Salesforce Tools
Salesforce Inspector Reloaded complements rather than replaces Salesforce’s native admin and developer tools. Understanding when to use each approach helps you work efficiently.
Setup effort comparison:
| Aspect | Native Tools | Salesforce Inspector |
|---|---|---|
| Availability | Always present in Setup | Requires one-time browser extension install |
| Configuration | None needed | No managed package, works immediately |
| Cross-org portability | Tied to each org’s Setup | Same extension works across all orgs |
Speed and accessibility:
Native Setup requires navigating menus, waiting for page loads, and scrolling through lists. Salesforce Inspector provides instant access from any record page. For quick, ad-hoc inspections of fields, metadata, or SOQL queries, the extension saves significant time.
However, native tools remain preferable for certain tasks:
Building or editing Flows: Flow Builder provides the visual canvas and debugging tools needed for development
Managing profiles and permission sets at scale: Setup’s bulk editing capabilities exceed what the extension offers
Creating custom objects: Object Manager handles the full creation workflow with all related configuration
Running Health Check and security reviews: Official tools provide compliance documentation
Many teams use both approaches. Salesforce Inspector handles rapid troubleshooting, metadata lookup, and quick queries. Setup, Developer Console, and official monitoring tools handle long-term governance and change control. The extension doesn’t replace or delete record capabilities through Data Loader for bulk operations, nor does it substitute for proper deployment tools.
One practical pattern: use Salesforce Inspector to investigate an issue, identify the root cause, then switch to native tools to implement the fix through proper channels. This balances speed with governance.
Limitations and Considerations
Salesforce Inspector Reloaded is a browser extension, which means it requires a supported browser, typically Chrome or Edge. In environments where IT policies lock down browser extensions, you won’t be able to use it. Incognito mode, or private browsing, also requires the extension to be explicitly enabled.
API usage considerations:
The extension uses Salesforce APIs on behalf of the logged-in user. Every action counts toward your org’s API limits:
Running SOQL queries consumes API calls
Describe calls for object metadata use API requests
Data exports trigger API activity
For orgs with tight API limits, heavy use of the extension adds up. Monitor your org’s API usage if you’re concerned, particularly before large import operations.
Security considerations:
Review the extension’s requested permissions before installation
Follow your organisation’s security policies for browser extensions
Restrict who can perform large imports or re-import operations
Be cautious when inspecting sensitive objects containing PII or financial data
Enterprises may require additional controls. Some organisations mandate SIEM logging, IP restrictions, or API client whitelisting. Formal approval processes might be needed before widespread deployment of any external tool browser extension.
Best practices:
Always test SIR features (especially import and bulk edit) in a sandbox first
Never bypass established deployment and approval processes
Don’t use the extension as a shortcut around change management
Document when and how the team uses the tool
The extension handles most use cases well, but it has some edge cases. Complex orgs with unusual configurations might encounter scenarios where native tools work better. The same version of the extension generally works across Salesforce editions, but verify in your specific environment.
How Tools Like Inspector Fit into a Broader Salesforce Governance Strategy
Extensions like Salesforce Inspector Reloaded sit alongside official tools, change management processes, and DevOps platforms in a mature Salesforce governance model. They’re not standalone solutions but components of a broader strategy.
Automation oversight:
Flow Scanner enables regular reviews of active flows. Teams can:
Deprecate unused flow versions systematically
Enforce consistent patterns across record-triggered flows
Document entry criteria and business logic
Catch risks before they reach production
This visibility supports architectural decisions about where automation should live and how it should be structured.
Metadata visibility:
Admins and architects can quickly inspect objects, fields, relationships, and limits. This supports:
Documentation efforts for new team members
Design decisions during project planning
Impact analysis before making changes
Dependency mapping for complex customisations
Technical debt management:
Extension-driven insights feed into practical governance activities:
| Insight Type | Governance Action |
|---|---|
| Field usage below 5% | Add to deprecation backlog |
| Complex flows with 50+ elements | Schedule refactoring sprint |
| Hard-coded IDs in automation | Create before next sandbox refresh |
| Approaching API limits | Review integration patterns |
These findings connect to backlog grooming, seasonal clean-up projects, and capacity planning.
Supporting scalable operations:
Faster troubleshooting reduces the risk of extended incidents. Quick metadata checks improve confidence in deployments. When businesses choose to scale their Salesforce implementations, these efficiencies compound.
Incorporate Salesforce Inspector into team playbooks and runbooks. Define clear guidelines on where it’s appropriate, how results are documented, and which activities still require native tools or formal approval processes.
Conclusion
Salesforce Inspector Reloaded 2.0 delivers tangible improvements that save admins hours of troubleshooting time each week. Faster metadata visibility means fewer clicks in Setup. The integrated SOQL editor and data export capabilities reduce context switching. And the overall performance improvements make the tool more pleasant to use across multiple Salesforce orgs.
Flow Scanner stands out as the most significant addition for modern Salesforce teams. As Flow becomes the core automation engine, replacing Workflow Rules and Process Builder, the risks of unmanaged automation grow. Hard-coded IDs, recursive triggers, and complex flows without fault paths can cause production incidents that damage user trust. Flow Scanner provides the visibility needed to identify issues proactively, before they create support tickets.
Identify gaps in your current automation and metadata oversight processes. Are you manually reviewing flows one by one? Are field inspections taking longer than they should? Is troubleshooting slowed by constant tab switching?
Here’s your practical next step: install or update Salesforce Inspector Reloaded in a sandbox environment. Run Flow Scanner against a few key objects, such as Opportunity or Case. Create a comprehensive guide for your team on how and when to use the tool. Define guidelines that balance speed with governance requirements. The extension is free, the learning curve is minimal, and the productivity gains are immediate.
