Exception Handling In Salesforce

Description of the image

Exceptions are like unexpected problems that happen when our code is running. They can cause big issues in our applications if we don't take care of them properly.
In my job, I've seen many times how these exceptions can cause trouble. Sometimes, the code doesn't work right because of unexpected data, or we reach Salesforce limits. Every time this happens, it's important to find and fix these problems quickly. This is what we call exception handling. It helps make sure our applications work well and don't have errors.

Handling exceptions well is key in Salesforce development. It makes sure our applications are strong and don't break easily. In this blog, I want to share what I've learned about this. I'll talk about different types of exceptions in Salesforce and how to handle them. I'll also share some examples from my own work. This will help you understand how to handle exceptions in your Salesforce projects.

Understanding Exceptions in Salesforce

In Salesforce, when we write and run code, sometimes things don't go as planned. These problems are what we call 'exceptions'. They are like roadblocks that stop our code from running smoothly. Think of it like driving a car and suddenly finding the road blocked. You need to know how to safely turn around and find another way.

What are Exceptions?

In Salesforce, exceptions are these unexpected events that happen while our code is running. They can be caused by many things, like trying to access a record that doesn’t exist, or when the code tries to do too much and crosses Salesforce’s limits. These exceptions tell us that something went wrong and needs our attention.

Types of Exceptions

Salesforce has many types of exceptions. Here are a few common ones:

  • DML Exception: This happens when there’s a problem with a database operation, like saving a record.
  • Query Exception: This occurs when something is wrong with a SOQL query, like syntax errors or if the query returns more records than Salesforce allows.
  • Limit Exception: Salesforce has strict limits to make sure no single process uses too many resources. This exception happens when those limits are crossed.
  • NullPointer Exception: This is common and happens when our code tries to use something that is not there (null).

Importance of Handling Exceptions

Why do we need to handle these exceptions? It’s because they can cause our applications to stop working or behave unexpectedly. By handling exceptions, we make sure our applications keep running smoothly, even if something goes wrong. 

This is very important for keeping the users of our applications happy. They don’t need to know the technical details; they just want the application to work. 

Proper exception handling helps ensure that the users have a good experience and that the application remains stable and reliable.

Benefits of Exception Handling in Salesforce 

When you handle exceptions well in Salesforce, it makes your apps work better and keeps your users happy. Here are some big benefits:

Keeps Your App Running Smoothly: Think of exceptions like little roadblocks in your app. Handling them well means your app keeps working even when it hits these bumps. This is super important for making sure your business keeps running without any hiccups.

Makes Users Happy: When exceptions are taken care of properly, users won’t run into sudden crashes or weird problems. This makes using the app a lot more pleasant for them. Happy users mean a good reputation for your app.

You Can Trust Your App More: If your app handles exceptions well, it means you can rely on it to work right all the time. This is really important for businesses that use Salesforce for important stuff.

Finds and Fixes Problems Faster: When you handle exceptions, you often keep track of them. This is like keeping a list of what went wrong and when. This list helps you figure out problems faster and fix them, which is great for keeping your app in tip-top shape.

Keeps Your Data Safe: Sometimes, if your app has a big problem and doesn’t know how to handle it, you might lose important data. Good exception handling stops this from happening, keeping your data safe and sound.

Strategies for Effective Exception Handling

Handling exceptions in Salesforce is a bit like preparing for the unexpected. We have to be ready to deal with issues when they happen, and there are several ways to do this effectively in Apex, Salesforce’s programming language.

Try-Catch Blocks

One common method is using try-catch blocks. This is like saying, “Try to do this, but if there’s a problem, catch it and do something else instead.” In Apex, we write a block of code in the ‘try’ section, and if an exception occurs, the ‘catch’ block takes over.

For example, in my work, I once had to update a list of records. I used a try-catch block to make sure if any record had issues, the code wouldn’t just stop. In the catch block, I added code to log the error. This way, the rest of the records could still be updated, and I could later check what went wrong with the problematic ones.

Custom Exceptions

Sometimes, the standard exceptions provided by Salesforce aren’t enough. In such cases, we can create our own custom exceptions. This is helpful when you want more control over what happens when an exception is thrown. You can define what the exception means and what should happen when it occurs.

Creating a custom exception is like making a specific rule for a specific problem. For instance, if I have a complex process where specific validation errors need special handling, I can create a custom exception for that. Then, I can catch this specific exception and handle it in a way that makes sense for that particular scenario.

Best Practices

There are some important best practices to follow for effective exception handling:

  • Avoid Empty Catch Blocks: Always do something with the caught exception. An empty catch block means you’re ignoring a potential problem. At the very least, log the error so you can review it later.
  • Log Errors for Future Analysis: Keeping a record of when and why exceptions happen can be very useful. It helps in understanding recurring issues and in improving the code.
  • Provide Useful Error Messages: When an exception occurs, provide a clear and helpful message. This is useful for users and for other developers who might work on your code later.
  • Don’t Overuse Try-Catch: While try-catch blocks are useful, don’t rely on them to handle every possible error. Sometimes, it’s better to let the exception occur and stop the process. This can prevent bigger issues down the line.

By following these strategies, we can make our Salesforce applications more robust and reliable. Exception handling is a crucial skill in Apex programming, and getting it right can significantly improve the quality of our applications.

Real-World Scenarios and Solutions

Exception handling is a critical part of Salesforce development, and I've encountered several scenarios where it was key to ensuring the smooth operation of the application. Here are a few real-world examples from my experience:

Scenario 1: Bulk Data Processing Error

Problem: I was working on a project where we needed to process a large amount of data from an external source. During the data upload, we encountered an issue where some records failed due to validation rules, causing the entire batch to fail.

Solution: I implemented a try-catch block within the batch processing code. In the catch block, I captured the failed records and logged the error details in a custom object for review. 

This allowed the rest of the batch to process successfully.

try {
    insert recordsList;
} catch (DmlException e) {
    // Continue processing other records

Outcome: The solution allowed the bulk data process to be completed successfully. We were able to review and rectify the failed records separately without hindering the overall process.

Lesson Learned: This experience taught me the importance of planning for partial successes in bulk operations, ensuring that a few failures don’t impact the entire batch.

Scenario 2: Unexpected System Limit Exception

Problem: In another project, a piece of code started to hit the governor limits unexpectedly, causing the entire operation to fail. This was particularly challenging because it was intermittent and hard to replicate.

Solution: To handle this, I added a try-catch block specifically to catch LimitException. In the catch block, I implemented a logic to gracefully exit the process and log detailed information about the state of the application when the exception occurred.

try {
    // Code that might hit governor limits
} catch (System.LimitException le) {
    // Graceful exit or alternative logic

Outcome: This approach helped in identifying the root cause of the limit issue. It also prevented the application from crashing, offering a more graceful handling of the limit exception.

Lesson Learned: It’s crucial to monitor and handle governor limit exceptions in Salesforce, especially in complex applications.

Advanced Techniques in Exception Handling

In Salesforce, as developers push the boundaries of what's possible, we often encounter complex situations requiring advanced exception-handling techniques. 

Here are some crucial areas where sophisticated exception handling plays a vital role.

Governor Limits and Exceptions

Salesforce imposes governor limits to ensure shared resources are used efficiently in the multi-tenant environment. However, these limits can lead to exceptions if not carefully managed.

  • Understanding the Limits: First, it's essential to understand the different types of governor limits, like SOQL query limits, DML limits, and CPU time limits.
  • Proactive Measures: To handle these limits, proactive measures are key. This includes optimizing SOQL queries, using collections and maps efficiently, and minimizing the use of DML operations in loops.
  • Exception Handling: When a governor limit is reached, Salesforce throws a Limit Exception. You can't catch some of these (like CPU time limit), but for others, you can use try-catch blocks to handle them gracefully.
  • Strategy: A good strategy is to monitor your resource usage throughout your code. If you’re approaching a limit, you can programmatically decide to halt the process or perform a less resource-intensive operation.

Asynchronous Apex and Exceptions

Handling exceptions in asynchronous Apex, such as Batch Apex or @future methods, requires a different approach since the execution context is different.

  • Batch Apex: In Batch Apex, you can use the Database.Stateful interface to maintain state across transactions. This can be useful for accumulating errors and dealing with them after the batch process is complete.
  • Future Methods: With @future methods, exception handling can be tricky since these methods don’t return a response to the calling code. It’s important to include comprehensive logging within these methods to capture any exceptions that occur.
  • Strategy: One effective strategy is to log exceptions to a custom object or use Salesforce’s built-in logging and monitoring tools. This way, you can review and address issues even though the process is asynchronous.

Using Monitoring Tools

Monitoring and logging are crucial for effectively managing exceptions, especially in complex Salesforce environments.

  • Debug Logs: Salesforce provides debug logs, which are invaluable for tracking down issues. By setting the appropriate log levels, you can capture detailed information about your code's execution.
  • Custom Logging: Sometimes, you might need more than what debug logs offer. Creating a custom logging system by logging exceptions to a custom object can provide a tailored view of errors and exceptions in your system.
  • Third-Party Tools: There are also third-party monitoring tools available on the Salesforce AppExchange that offer advanced features for monitoring, alerting, and analyzing exceptions and errors.

Also Read: 

What is Salesforce Role Hierarchy?

Maximize Sales with Salesforce CPQ: Top 10 Impactful Benefits!


Exception handling in Salesforce is about being proactive, using the right tools, and having a deep understanding of Salesforce’s execution context and limits. By implementing these advanced techniques, Salesforce developers can create more robust, efficient, and user-friendly applications.

Read More

Follow us on

Table of Contents

    Leave a reply

    Subscribe to Us

    Always Get Notified