Stateful vs Stateless Batch Apex in Salesforce: When and Why to Use Them

Batch Apex in Salesforce is a powerful tool for processing large datasets asynchronously. But did you know there are stateful and stateless approaches? Choosing the right one impacts performance, governor limits, and maintainability.

In this blog, you’ll learn:

✅ Key differences between stateful and stateless Batch Apex
✅ Real-world use cases for each approach
✅ Best practices for optimizing performance
✅ Common pitfalls and how to avoid them

Let’s dive in!

🔹 What is Batch Apex?

Batch Apex allows processing records in chunks (batches) to avoid governor limits. It implements three methods:

start() – Defines the scope.
execute() – Processes each batch.
finish() – Post-processing logic.

Basic Batch Apex Example

global class StatelessBatchExample implements Database.Batchable<sObject> {
    global Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id, Name FROM Account');
    }
    
    global void execute(Database.BatchableContext bc, List<Account> accounts) {
        // Process accounts (stateless)
        for (Account acc : accounts) {
            acc.Description = 'Updated by Batch';
        }
        update accounts;
    }
    
    global void finish(Database.BatchableContext bc) {
        System.debug('Batch completed!');
    }
}

🔹 Stateless Batch Apex

Definition: Each batch (execute method) runs independently without retaining data between batches.

✅ Use Cases:

Mass updates (e.g., updating Account descriptions).
Data cleansing (e.g., standardizing phone numbers).

❌ Limitations:

Cannot track progress across batches.
No shared variables between executions.

🔹 Stateful Batch Apex

Definition: Uses instance variables to maintain state across batches.

✅ Use Cases:

Aggregating data (e.g., counting Contacts per Account).
Complex multi-batch workflows (e.g., chaining batches).

Example: Counting Contacts per Account

global class StatefulBatchExample implements Database.Batchable<sObject>, Database.Stateful {
    global Integer totalContacts = 0; // Retains state
    
    global Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id FROM Account');
    }
    
    global void execute(Database.BatchableContext bc, List<Account> accounts) {
        for (Account acc : accounts) {
            Integer contactCount = [SELECT COUNT() FROM Contact WHERE AccountId = :acc.Id];
            totalContacts += contactCount; // Persists across batches
        }
    }
    
    global void finish(Database.BatchableContext bc) {
        System.debug('Total Contacts: ' + totalContacts);
    }
}

🔹 When to Use Each Approach

Criteria	Stateless	Stateful
Data Persistence	❌ No	✅ Yes
Use Case	Simple updates	Complex aggregations
Performance	Faster (no overhead)	Slower (state tracking)
Governor Limits	Lower risk	Higher risk (heap size)

⚡ Performance & Limits

Key Considerations:

Heap Size: Stateful batches consume more memory.
Transaction Limits: Each execute has its own governor limits.
Batch Size: Optimal size is 200-500 records (test for your org).

🏆 Best Practices

Use Stateless When Possible – Less memory overhead.
Avoid SOQL in Loops – Query data upfront in start().
Test with Realistic Data Volumes – Avoid surprises in production.
Log Progress – Use System.debug or Platform Events.
Chain Batches if Needed – Use finish() to trigger the next job.

🚨 Common Errors & Fixes

Error	Solution
Heap Size Exceeded	Reduce batch size or optimize queries.
Too Many SOQL Queries	Bulkify queries in `start()`.
State Not Persisting	Ensure `Database.Stateful` is used.

Header Ads Widget

Stateful vs Stateless Batch Apex in Salesforce: When and Why to Use Them

📋 Table of Contents