What is System Mode? Understanding Its Functionality and Importance

What is System Mode?

In the realm of software development, particularly within platforms like Salesforce, understanding the context in which your code operates is paramount. For Apex developers, this context is often referred to as System Mode. It’s essentially the operational environment that dictates the permissions, visibility settings, and overall behavior of your Apex code as it interacts with the platform’s data and functionalities.

Grasping System Mode isn’t just a technical nicety; it’s fundamental to writing secure, efficient, and predictable Apex code. Without this understanding, you might inadvertently create code that either exposes sensitive data or fails to perform as intended.

Key Aspects of System Mode

System Mode isn’t a single, monolithic concept. It’s a collection of behaviors and privileges that define how Apex code runs. Here are the core components:

Elevated Permissions: When Apex code runs in System Mode, it generally operates with what Salesforce considers elevated privileges. This often equates to having the equivalent of “View All Data” and “Modify All Data” permissions. This means your code can access and manipulate data that the actual user running the code might not typically have permissions for based on their profile or assigned permission sets.
Bypassing Sharing Rules: A significant characteristic of System Mode is its ability to bypass most standard sharing rules. This includes role hierarchies, manual sharing, and organization-wide sharing settings. Essentially, if your code is running in System Mode, it can access records that the logged-in user wouldn’t normally see or edit.
Respecting Object and Field-Level Security (for DML): While System Mode bypasses record-level sharing, it’s important to note that it still respects Object and Field-Level Security (FLS) for Data Manipulation Language (DML) operations. For instance, if a user’s profile doesn’t grant them permission to insert records of a particular object, Apex code running in System Mode will also fail to perform that insert operation.
Trigger Context: Triggers are a prime example of code that executes in System Mode. This is a critical point because triggers are often the first line of defense for enforcing business logic. Their elevated privileges mean trigger logic must be meticulously crafted to maintain data integrity and security, as they have the power to affect data broadly.
Default Behavior (“Without Sharing”): By default, Apex classes and methods that do not explicitly declare whether they should run “with sharing” or “without sharing” will execute in System Mode. This is often referred to as running “without sharing.”

When Does Apex Code Run in System Mode?

Understanding the scenarios where System Mode is active is crucial for anticipating your code’s behavior:

Standard Triggers: Whenever a record is created, updated, or deleted, the associated Apex triggers fire. These triggers operate in System Mode, allowing them to perform complex logic, update related records, or enforce business rules that might involve data outside the user’s immediate visibility.
Batch Apex: Batch Apex jobs, designed for processing large volumes of data asynchronously, typically run in System Mode. This is essential for efficiently handling extensive data operations.
Asynchronous Apex: Other forms of asynchronous Apex, such as Future Methods, Queueable Apex, and Scheduled Apex, also generally operate under System Mode privileges.
System Context Operations: Certain built-in Salesforce operations and integrations might also execute under System Mode, granting them broad data access for platform-level functions.

Controlling System Mode: Running with Sharing

The power of System Mode comes with a responsibility. To ensure your Apex code adheres to the running user’s specific permissions and sharing rules, Salesforce provides keywords to control this behavior:

The `with sharing` Keyword

Declaring an Apex class with the with sharing keyword is a powerful way to restrict your code’s execution context. It forces the code within that class to run strictly respecting the logged-in user’s profile permissions, sharing rules, and object/field-level security. If the user cannot perform an action, the code running with with sharing will also fail.


public with sharing class MySharingClass {
    // Code within this class will run respecting the logged-in user's sharing settings and permissions.
    public void doSomethingSecured() {
        // Any DML or SOQL operations here will be filtered by the user's access.
        List<Account> accessibleAccounts = [SELECT Id, Name FROM Account WHERE Name LIKE '%Test%'];
        // ... further operations
    }
}

The `without sharing` Keyword

Conversely, explicitly declaring a class or method with the without sharing keyword confirms that it should run in System Mode. While this is often the default behavior, using without sharing can enhance code clarity and explicitly communicate the developer’s intention to run with elevated privileges.


public without sharing class MySystemModeClass {
    // Code within this class will run with elevated privileges (System Mode).
    public void doSomethingElevated() {
        // This code can potentially access and modify records beyond the user's normal visibility.
        List<Account> allAccounts = [SELECT Id, Name FROM Account];
        // ... further operations
    }
}

Technical Notes & Best Practices

Navigating System Mode requires careful consideration:

Security Implications: Always be acutely aware of the security ramifications of running code in System Mode. Granting elevated privileges can inadvertently lead to data exposure or unintended data modifications if not handled with extreme caution.
Principle of Least Privilege: Whenever feasible, aim to run your Apex code with the minimum level of privilege necessary. If the user’s sharing and permissions need to be enforced, opt for the with sharing keyword.
Data Integrity: Even when operating in System Mode, your code must still adhere to Salesforce’s data validation rules, required field constraints, and other integrity measures. System Mode grants access, not a free pass to break data rules.
Thorough Testing: It is imperative to thoroughly test your Apex code under various user profiles and sharing scenarios. This will help you fully understand how System Mode (or the use of with sharing) impacts its behavior in different contexts.

Troubleshooting Common Issues

When developing Apex, you might encounter issues related to System Mode. Here’s how to approach them:

“Insufficient Privileges” Error: This is a classic indicator that your code is either running with sharing and the current user lacks the necessary permissions, or it’s trying to access data they don’t have visibility to.
- Check the Sharing Declaration: Verify if the Apex class is declared as with sharing or without sharing. If it’s intended to bypass sharing, ensure it’s without sharing. If it should respect user permissions, confirm it’s with sharing.
- User Permissions: Examine the running user’s profile and assigned permission sets. Do they have the required CRUD (Create, Read, Update, Delete) permissions on the objects your code is interacting with?
- Sharing Rules: If running with sharing, review the relevant sharing rules, role hierarchy, and manual sharing settings for the records your code is attempting to access.
Unexpected Data Access or Modification: If your Apex code is accessing or modifying data that a specific user shouldn’t be able to, and the class is declared without sharing, this is the expected System Mode behavior.
- Implement with sharing: The most straightforward solution is often to change the class declaration to with sharing to enforce user-specific access.
- Add Explicit Checks: Alternatively, if a class must run without sharing for certain operations, you can build explicit checks within your code to determine user access before performing sensitive actions.

Interview Relevance

Understanding System Mode is a common topic in Salesforce developer interviews. Be prepared to discuss:

What is System Mode in Apex and why is it important?
How does System Mode impact data visibility and permissions for Apex code?
When does Apex code typically run in System Mode by default?
What is the purpose and effect of the with sharing keyword?
Can you explain the difference between with sharing and without sharing?
In what specific scenarios would you choose to run Apex code in System Mode?
What are the critical security considerations when developing Apex code that runs in System Mode?
How do Apex triggers interact with System Mode, and what are the implications?

Real-World Scenarios

System Mode is not just an academic concept; it’s a practical necessity in many real-world Salesforce implementations:

Data Migration and Integration Tools: When migrating large datasets or integrating with external systems, Apex code often runs in System Mode. This allows for the efficient import, export, or update of vast amounts of data, bypassing individual user sharing restrictions to streamline the process.
Complex Automated Business Processes: For sophisticated automation that needs to update related records across different parts of the organization or enforce intricate business rules that span multiple data sets, System Mode is essential. It ensures that the automation can execute fully, regardless of the specific user’s access level.
Platform-Level Utilities and Integrations: Many platform-level utilities or integrations with external services require broad access to Salesforce data to perform their functions effectively. These operations are typically executed within System Mode to guarantee they have the necessary permissions.

By mastering the concept of System Mode and its control mechanisms like with sharing, you empower yourself to build robust, secure, and efficient Apex solutions on the Salesforce platform.