Curriculum
Bulkification is the process of designing Apex code to handle multiple records efficiently in a single execution. In Salesforce, Triggers can process one record or hundreds of records simultaneously. Therefore, developers must write code that works correctly regardless of the number of records being processed.
Bulkification is one of the most important concepts in Salesforce development because Salesforce enforces strict Governor Limits. Poorly designed triggers that process records one at a time can quickly exceed these limits and cause application failures.
Understanding Bulkification is essential for Salesforce Developers because every production-ready Trigger must be bulkified to ensure scalability, performance, and reliability.
Bulkification means writing Apex code that processes collections of records rather than individual records.
Instead of:
Process One Record
At A TimeUse:
Process Multiple Records
TogetherBulkification ensures code works efficiently in all scenarios.
Salesforce operations often process multiple records.
Examples:
A Trigger may receive:
1 Record
or
200 RecordsThe code must handle both situations efficiently.
Process records efficiently.
Avoid hitting limits.
Handle large data volumes.
Support enterprise applications.
Reduce execution failures.
These benefits make Bulkification essential.
When multiple records are saved:
Record 1
Record 2
Record 3
...
Record 200Salesforce executes the Trigger once for all records.
Not:
200 Separate Trigger ExecutionsThis behavior makes Bulkification necessary.
Example:
for(Student__c student :
Trigger.new){
}Trigger.new may contain:
Code must handle all records.
trigger StudentTrigger
on Student__c
(after insert) {
for(Student__c student :
Trigger.new){
Contact contact =
[
SELECT Id
FROM Contact
WHERE Email =
:student.Email__c
];
}
}Problem:
SOQL Query
Inside LoopThis may exceed Governor Limits.
Example:
200 Records
↓
200 SOQL QueriesSalesforce limit:
100 SOQL Queries
Per TransactionResult:
Governor Limit ExceptionThe transaction fails.
Set<String> emails =
new Set<String>();
for(Student__c student :
Trigger.new){
emails.add(
student.Email__c
);
}
List<Contact> contacts =
[
SELECT Id,
Email
FROM Contact
WHERE Email IN :emails
];Benefits:
This is a bulkified solution.
for(Student__c student :
Trigger.new){
Enrollment__c enroll =
new Enrollment__c();
insert enroll;
}Problem:
DML Inside LoopEach record performs a separate database operation.
Example:
200 Records
↓
200 InsertsSalesforce DML Limit:
150 DML StatementsResult:
Governor Limit ExceptionThe transaction fails.
List<Enrollment__c>
enrollments =
new List<Enrollment__c>();
for(Student__c student :
Trigger.new){
enrollments.add(
new Enrollment__c(
Student__c =
student.Id
)
);
}
insert enrollments;Benefits:
This is the recommended approach.
Bulkification relies heavily on collections.
Salesforce provides:
Collections improve performance and efficiency.
A List stores multiple records.
Example:
List<Student__c>
students =
new List<Student__c>();Useful for bulk DML operations.
A Set stores unique values.
Example:
Set<String> emails =
new Set<String>();Duplicate values are automatically removed.
Useful for SOQL filtering.
A Map stores key-value pairs.
Example:
Map<Id,Account>
accountMap =
new Map<Id,Account>();Maps provide fast record lookups.
Useful for large datasets.
Business Requirement:
Update Course enrollment counts.
Bulkified Solution:
Set<Id> courseIds =
new Set<Id>();
for(Student__c student :
Trigger.new){
courseIds.add(
student.Course__c
);
}Process all related Courses together.
This improves scalability.
Example:
for(Student__c student :
Trigger.new){
Student__c oldStudent =
Trigger.oldMap.get(
student.Id
);
if(
student.Status__c !=
oldStudent.Status__c){
}
}Multiple records can be compared efficiently.
Trigger Records
↓
Collect IDs
↓
Single SOQL Query
↓
Process Results
↓
Single DML OperationThis is the recommended Salesforce pattern.
Bulkification helps avoid:
Proper design keeps applications within Salesforce limits.
Business Requirement:
When Students are created:
Bulkified Approach:
Process All Students
↓
Create Collections
↓
Query Once
↓
Update Once
↓
Insert OnceThis supports enterprise scalability.
These techniques improve performance.
These practices support production-ready code.
Developers should avoid these issues.
A software training company imports:
10,000 Student RecordsA non-bulkified Trigger fails due to Governor Limits.
A bulkified Trigger:
This ensures successful processing.
Understanding Bulkification helps professionals:
Bulkification is one of the most critical Salesforce development skills.
Bulkification is the process of writing Apex code that efficiently handles multiple records in a single execution. Through the use of collections, bulk SOQL queries, bulk DML operations, Maps, Sets, and Lists, developers can build scalable and Governor-Limit-compliant Salesforce applications. Mastering Bulkification is essential for creating production-ready Apex Triggers and enterprise Salesforce solutions.
Bulkification is the process of designing Apex code to efficiently handle multiple records.
It helps avoid Governor Limit exceptions and improves scalability.
SOQL inside loops can exceed Salesforce query limits.
DML inside loops can exceed Salesforce DML limits.
Lists, Sets, and Maps.
It enables Salesforce applications to process large data volumes efficiently.
Looking to learn more technologies and programming skills?