Code more efficiently to avoid 'Apex CPU time limit exceeded'

What Is Counted Toward CPU Time

• All Apex code execution
• Library functions exposed in Apex
• Workflow rule execution
• Validation rule formula evaluation triggered by DML

What Is Not Counted Toward CPU Time

• Database operations: time spent executing SOQL queries, DML statements (insert, update, delete), and SOSL searches is not counted, as this processing occurs at the database layer, not the application server.
• Callout wait time: time spent waiting for an external API callout to return a response is not counted.
• Apex compilation time: time spent compiling Apex code is not counted.

Best Practices to Reduce CPU Time

You can refer to Apex Code Best Practices for a comprehensive guide. Key optimizations are described below.

Use Map-Based Queries Instead of For Loops to Build ID Sets

A common source of unnecessary CPU time is using a for loop to iterate over a list of records in order to build a Set of record IDs. Each iteration of the loop consumes CPU time proportional to the number of records.
A more efficient approach is to query records directly into a Map using the Map constructor with a SOQL query. For example, querying Account records into a Map of ID to Account automatically provides both the Set of IDs (via the keySet() method) and the List of Account records (via the values() method) — without any additional looping. Map-based queries also support retrieval of up to 50,000 records, compared to the 10,000 record limit for standard list queries.

Consider Running Operations Asynchronously

In some cases, a business process does not need to execute in real time. If code can be executed asynchronously (for example, using the @future annotation or Queueable Apex), this breaks the transaction context and also grants a much higher CPU time limit of 60,000 milliseconds (6 times the synchronous limit). Consider this approach if your synchronous code is at risk of hitting the CPU limit.

Use Aggregate SOQL to Push Calculations to the Database Layer

Since database processing time is not counted toward CPU time, it is more efficient to perform calculations at the database layer using SOQL aggregate functions such as SUM(), COUNT(), AVG(), and GROUP BY, rather than retrieving all records and performing the same calculations in Apex code with a for loop.
For example, to calculate the total value of all Opportunity records for an Account, use a SOQL query with SUM(Amount) rather than querying all Opportunities into a list and summing the amounts in a loop.

Only Retrieve the Fields and Records You Need

Retrieving more data than necessary increases the size of your loops and the amount of processing performed. Always filter SOQL queries to retrieve only the specific records and fields required for the operation, and avoid SELECT * patterns.