Mastering Salesforce Governor Limits for Optimal Performance

Understanding and working within Salesforce Governor Limits is critical for building scalable, high-performance applications on the platform. Salesforce enforces these limits to ensure fair resource allocation across all users and to maintain system stability. Ignoring them can lead to runtime exceptions, failed deployments, or even performance bottlenecks. Let’s break down the key governor limits and how to optimize your code to stay within them.

Common Salesforce Governor Limits

1. Heap Size Limit

The heap size limit restricts the total memory used by your Apex code, including objects, collections, and primitive data types. Exceeding this limit results in a HEAP_SIZE_LIMIT_EXCEEDED error.

Default Limit:

Synchronous Apex: 6 MB
Asynchronous Apex (Batch, Queueable, Schedulable): 12 MB

Optimization Tips:

Avoid storing large collections in memory. Use LIMIT clauses in SOQL queries to fetch only necessary data.
Process data in batches instead of loading entire datasets.
Use System.runAs() judiciously, as it creates new memory contexts.

Example:

// Bad: Loading all records without filtering
List<Account> allAccounts = [SELECT Id, Name FROM Account]; // Could exceed heap size

// Good: Query only required records
List<Account> activeAccounts = [SELECT Id, Name FROM Account WHERE IsActive = true LIMIT 1000];

2. CPU Time Limit

The CPU time limit measures the processing time consumed by your Apex code. Exceeding this causes a CPU_TIME_LIMIT_EXCEEDED error.

Default Limit:

Synchronous Apex: 10 seconds
Asynchronous Apex: 10 minutes (but best to stay under 10 seconds for efficiency)

Optimization Tips:

Minimize complex loops and nested loops.
Use bulkified triggers (process all records in a single transaction).
Offload heavy processing to asynchronous jobs.

Example:

// Bad: Nested loops causing high CPU usage
for (Account acc : accounts) {
    for (Contact con : acc.Contacts) {
        // Complex logic here
    }
}

// Good: Bulkify the logic
Map<Id, List<Contact>> contactsByAccount = new Map<Id, List<Contact>>();
for (Contact con : contacts) {
    contactsByAccount.put(con.AccountId, con);
}
for (Account acc : accounts) {
    if (contactsByAccount.containsKey(acc.Id)) {
        // Process contacts in bulk
    }
}

3. DML Statements Limit

The maximum number of DML operations allowed in a single transaction is 100,000. Exceeding this results in MAX_DML_STATES.

Optimization Tips:

Batch large DML operations using Database.update() or Database.insert() with collections.
Use Database.Batchable for processing large datasets.

Example:

// Bad: Multiple DML statements in a loop
for (Account acc : allAccounts) {
    acc.Name = 'Updated';
    update acc; // Fires DML for each record
}

// Good: Bulk DML
List<Account> accountsToUpdate = new List<Account>();
for (Account acc : allAccounts) {
    acc.Name = 'Updated';
    accountsToUpdate.add(acc);
}
update accountsToUpdate; // Single DML call

4. SOQL Queries Limit

The maximum number of SOQL queries allowed in a single transaction is 100,000. Exceeding this causes QUERY_LOOP.

Optimization Tips:

Avoid SOQL inside loops.
Use SELECT Id to minimize data retrieval when only IDs are needed.
Leverage LIMIT to restrict query results.

Example:

// Bad: SOQL inside a loop
for (Contact con : contacts) {
    Account acc = [SELECT Id FROM Account WHERE Id = :con.AccountId]; // Fires a query per loop
}

// Good: Query once outside the loop
Map<Id, Account> accountMap = new Map<Id, Account>();
for (Account acc : [SELECT Id, Name FROM Account WHERE Id IN :accountIds]) {
    accountMap.put(acc.Id, acc);
}
// Use accountMap to access accounts

5. SOOSL Queries Limit

The maximum number of SOOSL (Select SOQL with OFFSET) queries is 20. Exceeding this causes QUERY_LOOP.

Optimization Tips:

Avoid using OFFSET in queries.
Use LIMIT and pagination techniques instead.

6. Email Limits

Maximum emails sent per 24 hours: 100 (from Salesforce).
Maximum emails sent per transaction: 100.

Optimization Tips:

Use Messaging.singleEmailMessage for single emails.
For bulk emails, use Messaging.resendRequest or third-party services.

Tools for Monitoring Limits

Limits.getHeapSize(): Check current memory usage.
Limits.getCpuTime(): Monitor CPU time consumption.
Limits.getDmlStatements(): Track DML operations.
Debug Logs: Analyze runtime behavior and identify bottlenecks.

Best Practices

Bulkify Code: Ensure triggers and classes handle bulk data.
Avoid Recursion: Use static flags to prevent infinite loops.
Use Asynchronous Processing: Offload heavy tasks to @future, Queueable, or Batchable jobs.
Test for Limits: Write test cases that simulate large data volumes.

Conclusion

Mastering Salesforce Governor Limits is essential for building scalable and efficient applications. By understanding the constraints and applying optimization techniques like bulkification, asynchronous processing, and efficient querying, you can avoid runtime errors and ensure smooth performance. Regularly review your code and leverage Salesforce’s built-in tools to monitor and improve efficiency.

Please Wait

Comments (0)