Synchronous vs. Asynchronous Apex

Table of contents

• Synchronous Apex
• Asynchronous Apex
• Common Use Cases
• Synchronous vs. Asynchronous Apex

Synchronous and asynchronous Apex are two key execution modes in Salesforce that cater to different operational needs and use cases. Synchronous Apex executes immediately in a single thread, making it ideal for real-time processing where the result is needed instantly. This mode is commonly used in triggers, batch updates, and scenarios requiring immediate feedback, such as updating a record based on user input.

Asynchronous Apex, on the other hand, operates in a separate thread, allowing for background processing. This is particularly useful for long-running operations, complex calculations, and integrations that do not need immediate completion. Methods like future methods, batch Apex, and scheduled Apex are examples of asynchronous execution. By leveraging asynchronous processing, developers can enhance the performance and responsiveness of their applications, avoiding the limitations imposed by Salesforce’s synchronous execution limits. Understanding the appropriate use of synchronous and asynchronous Apex is crucial for optimizing application performance and ensuring efficient resource utilization in Salesforce environments.

Are you looking to upgrade your career in Salesforce? Yes, we have the perfect solution for you with our comprehensive Salesforce training in Hyderabad. This course is designed to cover everything you need to know, from admin and developer roles to LWC modules, ensuring you become job-ready. Enroll for free demo today!

Synchronous Apex – Immediate Actions

Synchronous Apex in Salesforce is designed to execute code in a single thread, processing tasks immediately and providing instant results. This mode of execution is crucial for scenarios where immediate feedback is necessary, such as when a user interacts with the application and expects an instant response. For instance, when a record is created or updated, synchronous Apex can trigger immediate validation, apply business logic, and update related records in real-time. This real-time processing ensures that the user receives immediate confirmation of their actions, enhancing the overall user experience.

A common use case for synchronous Apex is within triggers. Triggers are used to perform operations before or after record modifications, such as insertions, updates, or deletions. Since triggers need to complete their execution promptly to provide immediate feedback to the user, they run synchronously. This immediate execution is essential for maintaining data integrity and enforcing business rules. Synchronous Apex is also employed in batch updates and workflows where the outcome is required immediately to proceed with subsequent operations or to maintain transactional integrity.

However, the synchronous nature of this execution mode comes with certain limitations, particularly concerning governor limits imposed by Salesforce. Governor limits are restrictions that ensure efficient use of resources by enforcing limits on the number of database operations, CPU time, and memory usage for each transaction. Synchronous Apex must operate within these constraints, which can be challenging when dealing with large datasets or complex calculations. To mitigate these limitations, developers must carefully optimize their code, ensuring that it runs efficiently and does not exceed the prescribed limits. Understanding and adhering to these constraints is essential for successful synchronous Apex development, ensuring that applications remain responsive and performant.

Enroll for the free demo of this Salesforce course today – a job-oriented, certification-focused learning path that’s designed to help you achieve your career goals.

Why Synchronous Apex Is Used?

Synchronous Apex in Salesforce is used when a process or transaction needs to be completed in real-time, meaning the user must wait for the operation to finish before proceeding. This type of Apex execution is crucial in scenarios where immediate feedback is necessary or where the result of the operation impacts the next steps in the workflow. For example, when a user saves a record, Synchronous Apex can be used to ensure that all necessary validations, calculations, or updates are performed instantly before the record is saved.

One key reason for using Synchronous Apex is to maintain data integrity and consistency. In processes like updating related records, calculating roll-up summaries, or executing complex business logic, Synchronous Apex ensures that these operations are completed without delay, providing immediate feedback to the user. This is particularly important in scenarios where subsequent operations depend on the outcome of the initial transaction.

Another reason to use Synchronous Apex is in scenarios where you need to enforce strict transactional behavior. Since Synchronous Apex runs within the same transaction context, it allows for operations to be rolled back if any part of the transaction fails. This is essential for maintaining consistency, especially in complex systems where multiple records or operations are involved.

However, it’s important to note that Synchronous Apex is subject to Salesforce’s governor limits, which can impact performance in cases of large data volumes or intensive processing. Therefore, while Synchronous Apex is powerful for real-time processing, it’s essential to carefully design your logic to avoid hitting these limits.

Asynchronous Apex – Scheduled Tasks

Asynchronous Apex in Salesforce allows processes to run in the background without interrupting the user experience. Scheduled Apex is a type of Asynchronous Apex that lets you schedule Apex classes to execute at specific times, making it ideal for automating repetitive tasks, such as data cleanup, report generation, or batch processing.

Example: Daily Lead Cleanup

Imagine you need to clean up outdated leads in your Salesforce org every night. To achieve this, you can create an Apex class that implements the Schedulable interface. This class will contain the logic for identifying and deleting leads that are older than a certain date.

global class LeadCleanup implements Schedulable {
    global void execute(SchedulableContext sc) {
        // Logic to delete outdated leads
        List<Lead> oldLeads = [SELECT Id FROM Lead WHERE CreatedDate < LAST_N_DAYS:365];
        delete oldLeads;
    }
}

Once the class is defined, you can schedule it to run daily at midnight using the System.schedule method:

System.schedule('Daily Lead Cleanup', '0 0 0 * * ?', new LeadCleanup());

This approach ensures that your leads are cleaned up automatically every day without any manual effort, improving data quality and maintaining an organized CRM system.

Why Asynchronous Apex Is Used?

Asynchronous Apex in Salesforce is designed to handle operations that do not require immediate execution, allowing them to run in the background without interrupting the user experience. This mode is particularly beneficial for long-running processes, complex calculations, and tasks that might exceed the governor limits imposed on synchronous operations. By decoupling these operations from the immediate user interaction, asynchronous Apex enables developers to execute resource-intensive tasks efficiently and without impacting the performance of the main application.

A key use case for asynchronous Apex is in processing large datasets. Methods like future methods, batch Apex, and scheduled Apex allow developers to perform operations on thousands of records in manageable chunks, ensuring compliance with Salesforce’s governor limits. For example, batch Apex processes data in discrete batches, reducing the risk of hitting CPU time or memory limits. Scheduled Apex, on the other hand, enables the execution of Apex classes at specified times, automating repetitive tasks like nightly data synchronization or periodic updates. Future methods allow for the execution of operations that can be deferred, enabling a seamless user experience even when complex processes are involved.

Example: Batch Apex for Processing Large Data Sets

One common use of Asynchronous Apex is Batch Apex, which allows you to process large volumes of records in manageable chunks.

Here’s a basic example of a Batch Apex class:

global class UpdateAccountBatch implements Database.Batchable<SObject> {

    global Database.QueryLocator start(Database.BatchableContext BC) {
        // Query to fetch large number of Account records
        return Database.getQueryLocator('SELECT Id, Name FROM Account WHERE Status__c = \'Inactive\'');
    }

    global void execute(Database.BatchableContext BC, List<SObject> scope) {
        // Process each batch of Account records
        for (Account acc : (List<Account>)scope) {
            acc.Status__c = 'Active';
        }
        update scope;
    }

    global void finish(Database.BatchableContext BC) {
        // Final actions after all batches are processed
        System.debug('Batch process completed');
    }
}

In this example:

• The start method defines the query to select a large number of Account records.
• The execute method processes each batch of records by updating the Status__c field.
• The finish method is called after all the batches are processed.

You can execute this batch class asynchronously using the following code:

UpdateAccountBatch batch = new UpdateAccountBatch();
Database.executeBatch(batch, 200);

This way, Asynchronous Apex enables you to handle large-scale operations efficiently without impacting the user experience.

Read more: Salesforce Experience Cloud Interview Questions

Despite its advantages, asynchronous Apex also requires careful management to ensure optimal performance and resource utilization. Developers must handle potential issues such as job queue delays and error handling in background processes. Salesforce provides tools to monitor and manage asynchronous jobs, such as the Apex Jobs page in the Salesforce setup menu, which offers visibility into job statuses and performance. Properly leveraging asynchronous Apex not only enhances application performance and scalability but also ensures that critical background tasks are completed efficiently. By understanding the appropriate use cases and implementing robust error handling and monitoring practices, developers can maximize the benefits of asynchronous Apex in their Salesforce applications.

Common Use Cases

Common Use Cases for Synchronous Apex

Real-Time Data Validation and Business Logic Execution:

Synchronous Apex is ideal for scenarios requiring immediate validation and execution of business logic. For example, when a user submits a form, synchronous triggers validate the data and enforce business rules, providing instant feedback to ensure data integrity.

Before and After Triggers:

Synchronous triggers are essential for operations that must occur immediately before or after record changes. For instance, a before-insert trigger can enforce field-level validations, while an after-update trigger can propagate changes to related records or initiate subsequent workflows.

Immediate Workflow Actions:

Workflow rules and processes that need to execute actions like sending emails, updating fields, or creating tasks immediately after a record is saved rely on synchronous Apex. This ensures that these actions occur without delay, providing instant feedback and maintaining process integrity.

User Interface Interactions:

Synchronous Apex is used for user interface interactions where instant responses are expected. For example, updating a record’s status or generating an on-the-fly summary based on user inputs within a Visualforce page or Lightning component requires synchronous execution to ensure a seamless user experience.

Transactional Integrity:

Maintaining transactional integrity is crucial in scenarios like financial transactions or inventory management. Synchronous Apex ensures that all operations within a transaction are completed successfully or rolled back in case of an error, preserving data consistency and reliability.

Read more: Accenture Salesforce Developer Interview Questions

Common Use Cases for Asynchronous Apex

Batch Processing of Large Data Sets:

Asynchronous Apex, particularly batch Apex, is used to handle operations on large volumes of data. For example, updating millions of records, performing data cleansing, or running complex calculations that exceed the limits of synchronous processing can be efficiently managed in batches.

Scheduled Tasks and Automation:

Scheduled Apex allows for the automation of repetitive tasks that need to run at specific times. This is useful for daily or weekly reports, data synchronization with external systems, and routine maintenance tasks that can be executed during off-peak hours to reduce system load.

Future Methods for Deferred Processing:

Future methods enable the execution of operations that can be deferred to a later time, improving the responsiveness of the main application. For instance, integrating with external services, sending asynchronous notifications, or processing data-intensive tasks can be handled without impacting the user experience.

Complex Calculations and Long-Running Processes:

Asynchronous Apex is ideal for operations that require extensive computations or long-running processes. For example, recalculating complex pricing models, generating large reports, or aggregating data from multiple sources can be managed asynchronously to ensure optimal performance and resource utilization.

Integration with External Systems:

Asynchronous Apex facilitates integration with external systems where real-time responses are not required. For instance, making callouts to third-party APIs, syncing data with external databases, or processing inbound data feeds can be efficiently managed in the background, ensuring that the main application remains responsive.

Read more: Roles and Profiles in Salesforce Interview Questions

Example of Synchronous vs. Asynchronous Apex

Let’s consider a scenario where you need to validate data and update a related record immediately when a new contact is created. In this example, we use a trigger to enforce business logic synchronously.

Trigger to validate and update data synchronously:

trigger ContactTrigger on Contact (before insert, before update) {
    for (Contact contact : Trigger.new) {
        // Validate that the email field is not empty
        if (String.isBlank(contact.Email)) {
            contact.addError('Email cannot be blank');
        }

        // Update related account's last modified date
        if (contact.AccountId != null) {
            Account acc = [SELECT Id, LastModifiedDate FROM Account WHERE Id = :contact.AccountId LIMIT 1];
            acc.LastModifiedDate = System.now();
            update acc;
        }
    }
}

In this synchronous example, the trigger runs immediately when a contact is created or updated, enforcing validation rules and updating the related account’s last modified date in real-time.

Example of

Now, let’s consider a scenario where you need to process a large number of records in the background without blocking the user interface. We can use a Batch Apex job to handle this asynchronously.

Batch Apex to process large data sets asynchronously:

global class ContactBatchUpdate implements Database.Batchable<sObject> {
    
    global Database.QueryLocator start(Database.BatchableContext BC) {
        return Database.getQueryLocator([SELECT Id, Email FROM Contact WHERE Email != NULL]);
    }
    
    global void execute(Database.BatchableContext BC, List<Contact> scope) {
        for (Contact contact : scope) {
            // Perform some complex processing
            contact.Email = contact.Email.toLowerCase();
        }
        update scope;
    }
    
    global void finish(Database.BatchableContext BC) {
        // Send an email notification upon completion
        Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
        email.setSubject('Batch Job Completed');
        email.setPlainTextBody('The batch job to process contacts has completed successfully.');
        email.setToAddresses(new String[] {'admin@example.com'});
        Messaging.sendEmail(new Messaging.SingleEmailMessage[] {email});
    }
}

To run this batch job:

ContactBatchUpdate batch = new ContactBatchUpdate();
Database.executeBatch(batch, 200);

In this asynchronous example, the batch job processes contacts in chunks of 200 records at a time, updating their email addresses to lowercase. The finish method sends an email notification upon completion. This allows the processing to happen in the background without affecting the user interface or hitting governor limits, providing a scalable solution for handling large data volumes.

Learn Salesforce in Hyderabad: Advance Your Career with Key Skills and Opportunities

Salesforce has become a critical skill for professionals, especially in tech-driven cities like Hyderabad. As a major IT hub in India, Hyderabad is home to several top software companies that rely heavily on Salesforce for customer relationship management (CRM) and other essential business functions. By enrolling in a Salesforce training in Hyderabad, you can master areas such as Salesforce Admin, Developer (Apex), Lightning, and Integration, significantly boosting your career prospects. Global tech giants like Google, Amazon, and Microsoft are constantly on the lookout for certified Salesforce professionals. The demand for these skills is high, and salaries in this field are extremely competitive. To tap into these opportunities, it’s important to choose one of the top Salesforce training institutes in Hyderabad. CRS Info Solutions stands out as a leader, offering specialized courses that can prepare you for certification and a successful career in Salesforce.

Why Salesforce Training in Hyderabad is Essential

Hyderabad has emerged as a thriving tech city, attracting global corporations and fostering a high demand for skilled professionals. Salesforce is one of the most sought-after skills due to its crucial role in CRM and business management. Opting for Salesforce training institutes in Hyderabad offers a significant edge, as the city’s robust job market is consistently growing. Leading companies like Google, Amazon, and Microsoft are actively searching for certified Salesforce experts to manage and optimize their Salesforce systems.

Specialists trained in Salesforce Admin, Developer (Apex), Lightning, and Integration modules are particularly valued. Certified professionals not only experience high demand but also enjoy competitive salaries in Hyderabad’s tech sector. This makes pursuing Salesforce training an excellent career decision, offering both financial rewards and opportunities for professional growth.

What You Will Learn in a Salesforce Course?

When you choose Salesforce training in Hyderabad, you will be exposed to various modules that cover everything from basic to advanced concepts. Here’s what you can expect to learn:

• Salesforce Admin: Understand how to configure and manage Salesforce CRM, customize dashboards, and automate processes to meet business needs.
• Salesforce Developer (Apex): Gain expertise in Apex programming to build custom applications and automate processes within Salesforce.
• Lightning Framework: Learn to develop interactive, user-friendly applications using Salesforce’s Lightning framework for better performance and scalability.
• Salesforce Integration: Explore how to integrate Salesforce with other systems, ensuring seamless data flow and better efficiency in business operations.
• Lightning Web Components (LWC): Master modern web development using LWC, a new way to build faster and more dynamic user interfaces on the Salesforce platform.

These courses are designed to equip you with hands-on experience and practical skills that will be invaluable in a real-world work environment.

Why Choose CRS Info Solutions for Salesforce Training in Hyderabad

Choosing the right Salesforce training institute in Hyderabad is crucial for a successful career. CRS Info Solutions is one of the top-rated Salesforce training institutes, offering a wide range of courses covering essential modules like Admin, Developer, Integration, and Lightning Web Components (LWC). With experienced instructors, CRS Info Solutions provides a comprehensive learning experience, combining both theoretical knowledge and practical application.

CRS Info Solutions is committed to helping you achieve Salesforce certification and build a promising career in the tech industry. The institute’s emphasis on practical learning and real-world applications ensures that you are fully prepared for opportunities in top companies like Google, Amazon, and Microsoft. With attractive salaries and a growing demand for Salesforce expertise in Hyderabad, investing in Salesforce training from CRS Info Solutions is the ideal way to secure a rewarding and successful career.

Register for Free Demo Now!