Salesforce is a powerful customer relationship management (CRM) platform that helps businesses keep track of their customers and sales. One of the most powerful features of Salesforce is its ability to automate tasks using triggers. A trigger is a piece of code that runs automatically when an event occurs.

For example, a trigger can be set to run when a record is created or updated. Triggers are very versatile and can be used to perform a wide variety of actions, such as sending an email notification or updating another record. However, one thing that triggers cannot do is call future methods.

Future methods are pieces of code that run asynchronously, meaning they do not run immediately. Instead, they are queued up and run at a later time. The reason why future methods cannot be called from triggers is because they are not guaranteed to finish running before the next transaction starts.

This could cause problems if the future method tries to update the same record that was just updated by the trigger. To avoid these sorts of conflicts, Salesforce does not allow future methods to be called from triggers.

  • In Salesforce, open the developer console
  • In the developer console, open the Execute Anonymous window
  • In the Execute Anonymous window, enter the following code: TriggerHandler
  • callFutureMethod(); 4
  • Click “Execute

Calling future method from Trigger

Call Future Method from Trigger Example

Salesforce provides a powerful tool for automating business processes – Apex triggers. These triggers can be used to perform a wide variety of actions, from simple field updates to complex data validation and process automation. One of the most powerful features of Apex triggers is the ability to call future methods.

Future methods allow you to asynchronously execute Apex code that is not tied to the current transaction. This means that your trigger can continue processing records even if the called future method takes a long time to complete. Calling a future method from a trigger is relatively straightforward.

First, you need to annotate your future method with the @future annotation. This tells Salesforce that the method can be executed asynchronously. Next, you simply call the method from your trigger as you would any other Apex code.

Here’s a simple example of how this might work in practice: trigger UpdateContact on Contact (before insert) { // Call our future method for each contact being inserted

for (Contact c : { updateContactAsync(c); } } // Annotated with @future so it can be executed asyncronously @future public static void updateContactAsync(Contact c) {


Can We Call Future Method from Batch Class

Yes, you can call future methods from batch classes. However, there are a few things to keep in mind when doing so. First, all future methods must be called from the execute() method of the batch class.

Second, any code that needs to be executed after the future method has completed its work must be placed in a finish() method. Third, if your batch class is going to make use of Database.Stateful objects (such as ApexPages or SObjects), you need to first call Database.executeBatch() from within your execute() method before calling any future methods; otherwise, you’ll get an error. Finally, remember that since future methods are asynchronous, they may not always complete their work before the finish() method is executed; therefore, your code should take this into account and account for any possible race conditions.

Can We Call Batch Class from Trigger

Salesforce provides a powerful platform for building custom applications. One of the key features of the platform is its ability to automate business processes using triggers. Triggers are pieces of code that execute automatically when certain events occur in Salesforce, such as when a record is created or updated.

One common use for triggers is to call batch classes. Batch classess allow you to process large volumes of data in an asynchronous way, meaning that your trigger can continue processing other records while the batch class is running in the background. This can be a great way to improve performance and avoid hitting governor limits.

To call a batch class from a trigger, you simply need to add a few lines of code to your trigger handler. First, you’ll need to create an instance of the batch class: BatchClass myBatchClass = new BatchClass();

Then, you’ll need to specify what type of data you want to pass into the batch class (usually either a list of sObjects or IDs): myBatchClass.execute(listOfSobjects); // OR myBatchClass.execute(listOfIds); Finally, you’ll need to add some error handling in case there are any problems with calling the batch class:


Can We Call Future Method from Future Method

Can We Call Future Method from Future Method? We can call future methods from future methods, but there are some restrictions. First, only one future method can be executed at a time.

So if a second future method is called while the first one is still running, the second one will wait until the first one finishes. Second, we can’t call a future method from a trigger or Visualforce page. The reason for this is that triggers and Visualforce pages are already asynchronous, so calling a future method would just make things more complicated.

Finally, we need to be careful about recursion – if a future method calls itself, it will never finish!

Can We Call Future Method From Trigger in Salesforce?


How Many Future Method Can Be Called from Trigger?

In general, it is not a recommended practice to call future methods from triggers. This is because future methods are asynchronous, meaning that they are not executed immediately. This can cause issues with data consistency if the trigger and future method are working with the same data.

There are some circumstances where it may be necessary to call a future method from a trigger. For example, if you need to make a callout to an external API as part of the trigger logic. In this case, you would need to use a trigger handler class so that you can control when the callout is made (after the database transaction has been completed).

It is also worth noting that there is a limit of 10 future calls per Apex transaction. So if your trigger makes multiple calls to future methods, it is possible to exceed this limit.

Can We Call Future Method from before Insert Trigger in Salesforce?

Before insert triggers are used to perform custom actions before a record is inserted into the database. Future methods can be called from these triggers to perform actions asynchronously. This means that the trigger will continue processing records even if the future method is still running.

This can be useful when performing long-running operations that do not need to be completed before the trigger finishes processing records.

Can We Call Future Method from Controller?

Yes, we can call future methods from controllers. In fact, this is a common use case for asynchronous Apex. By using the @future annotation on a method, we can indicate that the method should be executed asynchronously—in other words, in a separate thread outside of the main controller logic.

This has several benefits: 1) It allows us to keep our controller logic lean and focused on the main task at hand—in this case, handling the incoming request and returning a response. 2) It helps improve performance by offloading some work to be done in parallel with the rest of the controller logic.

3) And it makes our code more resilient to failure since any exceptions that occur in the future method will not impact the main controller logic.

Can We Call Queueable from Trigger?

Yes, you can call Queueable from trigger. In fact, it is a best practice to do so when possible to avoid hitting governor limits. When you enqueue a job from a trigger, the job is placed on the Apex flex queue and is executed asynchronously.

This means that your triggers can continue processing records while the jobs are being processed in the background.


Salesforce Developers are always looking for ways to automate processes and make their lives easier. One way to do this is by using triggers to call future methods. However, there are some limitations to this approach that developers need to be aware of.

In this blog post, we’ll take a look at what those limitations are and how developers can work around them.