Curriculum
After Triggers are Apex Triggers that execute after records have been saved to the Salesforce database. Unlike Before Triggers, After Triggers run when the record already exists in the database and has been assigned a Salesforce Record ID.
After Triggers are commonly used to create related records, update parent records, perform integrations, send notifications, maintain audit logs, and execute processes that require access to the saved record. They are widely used in enterprise Salesforce applications where actions must occur after data has been successfully committed.
Understanding After Triggers is essential for Salesforce Developers because they play a critical role in automation, integrations, and advanced business process implementation.
An After Trigger executes after Salesforce commits a record to the database.
The Trigger runs during:
At this stage:
Record Already SavedThe record now has a valid Salesforce ID.
Organizations often need to:
These actions typically require the record to already exist in Salesforce.
Work with newly created records.
Generate child records automatically.
Send data to external systems.
Synchronize related data.
Support enterprise business processes.
These benefits make After Triggers highly valuable.
Salesforce supports four After Trigger events.
Each event serves a different purpose.
An After Insert Trigger executes after a new record is saved.
At this point:
Record Exists
In DatabaseThe record ID is available.
trigger StudentTrigger
on Student__c
(after insert) {
}This Trigger executes after Student records are created.
Business Requirement:
Every new Student should receive an Enrollment record.
Trigger:
trigger StudentTrigger
on Student__c
(after insert) {
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;
}The Student ID is available because the record already exists.
Student:
Rahul SharmaEnrollment:
Enrollment Created
AutomaticallyAutomation occurs immediately after record creation.
An After Update Trigger executes after a record has been updated.
Common Uses:
The updated values already exist in Salesforce.
trigger StudentTrigger
on Student__c
(after update) {
}The Trigger executes after updates are saved.
Business Requirement:
Notify management when a student’s course changes.
Trigger:
trigger StudentTrigger
on Student__c
(after update) {
for(Integer i = 0;
i < Trigger.new.size();
i++){
if(
Trigger.new[i]
.Course__c !=
Trigger.old[i]
.Course__c){
System.debug(
'Course Changed'
);
}
}
}The Trigger detects record changes.
Output:
Course ChangedThis event can trigger additional automation.
An After Delete Trigger executes after records are removed from Salesforce.
Common Uses:
Deleted records remain accessible through Trigger.old.
trigger StudentTrigger
on Student__c
(after delete) {
}The Trigger executes after deletion.
trigger StudentTrigger
on Student__c
(after delete) {
for(Student__c student :
Trigger.old){
System.debug(
student.Name +
' Deleted'
);
}
}Deletion activity is recorded.
Output:
Rahul Sharma DeletedUseful for auditing purposes.
An After Undelete Trigger executes when records are restored from the Recycle Bin.
Common Uses:
This event is unique to Salesforce.
trigger StudentTrigger
on Student__c
(after undelete) {
}The Trigger executes after restoration.
trigger StudentTrigger
on Student__c
(after undelete) {
for(Student__c student :
Trigger.new){
System.debug(
student.Name +
' Restored'
);
}
}Restoration activities can be tracked.
Output:
Rahul Sharma RestoredThe record is available again.
Trigger.new contains records after they have been saved.
Example:
for(Student__c student :
Trigger.new){
}Available in:
Records now have valid Salesforce IDs.
for(Student__c student :
Trigger.new){
System.debug(
student.Id
);
}Record IDs can now be used.
Trigger.old contains previous versions of records.
Example:
for(Student__c student :
Trigger.old){
}Available in:
Used for comparison and auditing.
if(
Trigger.new[i]
.Status__c !=
Trigger.old[i]
.Status__c
){
}Useful for tracking changes.
Example:
trigger StudentTrigger
on Student__c
(after update) {
for(Integer i = 0;
i < Trigger.new.size();
i++){
if(
Trigger.new[i]
.Status__c !=
Trigger.old[i]
.Status__c){
System.debug(
'Status Updated'
);
}
}
}This identifies field changes.
Business Requirement:
Update Course enrollment count when a Student is added.
Trigger:
trigger StudentTrigger
on Student__c
(after insert) {
}After Triggers are ideal for parent-child synchronization.
After Triggers commonly support:
Because records already exist, integration becomes easier.
Organizations often require audit records.
Example:
Audit_Log__cAfter Triggers can create logs whenever records change.
Useful for compliance and reporting.
Triggers must handle multiple records.
Example:
for(Student__c student :
Trigger.new){
}Never assume only one record is processed.
Bulkification is mandatory.
These are among the most common enterprise scenarios.
These advantages make After Triggers powerful tools.
Developers must design carefully.
| Feature | Before Trigger | After Trigger |
|---|---|---|
| Record Saved | No | Yes |
| Record ID Available | No | Yes |
| Modify Current Record | Yes | Not Recommended |
| Create Related Records | Limited | Yes |
| Integrations | Limited | Yes |
Understanding the differences is important.
These practices support scalable development.
Developers should avoid these issues.
A software training company requires:
After Triggers automate these actions immediately after records are saved.
This improves operational efficiency.
Understanding After Triggers helps professionals:
After Triggers are widely used in professional Salesforce development.
After Triggers execute after Salesforce records are saved, updated, deleted, or restored. Through After Insert, After Update, After Delete, and After Undelete events, developers can create related records, update parent objects, perform integrations, generate audit logs, and automate complex business processes. Because record IDs are available and data already exists in Salesforce, After Triggers provide powerful capabilities for enterprise application development.
An After Trigger executes after a record is saved to the Salesforce database.
After Insert, After Update, After Delete, and After Undelete.
They are used for related record creation, integrations, and parent record updates.
Yes. The record already exists and has a Salesforce ID.
Trigger.old stores previous record values during updates and deletions.
Related record creation, audit logging, notifications, and integrations.
Looking to learn more technologies and programming skills?