Salesforce Development Best Practices to Learn in 2025

Publish date:

• 15th July, 2025

Salesforce provides software that customers can access online. It follows a subscription model, allowing users to pay as they go. Since Salesforce is cloud-based, you can use it from any device, and all your data is stored online. It also allows you to track data in real-time and get accurate updates.

Salesforce offers a comprehensive set of services to all customers in its multi-tenant cloud. No matter your company's size, you can access the same tools. Salesforce has policies in place to ensure that you and your customers can access most of the resources available.

Salesforce is very popular, with 62.1 percent of its CRM users located in the United States. Some of its well-known customers include Walmart, UnitedHealth Group, and McKesson Corporation.

Here are some essential facts about Salesforce:

• More than 150,000 companies use Salesforce, which earned $21.25 billion in 2021.

• Salesforce holds a 19.8% share of the CRM market. It exceeds the combined share of its top four competitors.

• The company employs 56,606 people.

• Salesforce's revenue grew by over 24.27% compared to the previous year.

• Over the last 20 years, Salesforce's revenue has increased at an average annual rate of 51.22%.

• Salesforce divides its revenue into two parts: subscriptions and support, and professional services and other sources.

• The primary source of Salesforce's revenue comes from subscriptions and support. It includes cloud services, software licenses, and related technical support.

• The subscription and support section makes up 93.99% of the total revenue, which is $19.98 billion. It represents a 24.51% increase from the 2020 fiscal year.

• The professional services and other revenues account for 6.01% of overall revenue. This category generated $1.28 billion, representing a 21.9% increase from the previous year.

Now that we've examined Salesforce's success, let's explore its primary uses.

• Also Read: Signs your Business needs Salesforce Development 

What Is Salesforce Used For?

The CRM platform is cloud-based software, which means that different departments within a company can connect, regardless of their location. Salesforce creates and updates CRM software that helps companies overcome technology barriers. It enables them to gain a comprehensive view of their customers across all channels. A CRM platform allows companies to gain a deeper understanding of their customers and improve the customer experience during interactions.

How does it work?

Salesforce offers several cloud platforms, each with different features. Here are a few of them:

Sales Cloud

Sales Cloud includes resources for sales, marketing, and customer service. It helps organizations provide personalized shopping experiences to customers in both business-to-business (B2B) and business-to-consumer (B2C) settings.

Marketing Cloud

Businesses can communicate with customers at the right time through various channels using the marketing cloud. It helps create personalized content for each user based on their interests and online behavior. Companies can gather data from a person’s social media accounts, shopping habits, and other sources.

Analytics Cloud

The Einstein Sales Analytics cloud, also known as the Analytics cloud, enables organizations to work more effectively with their data, ultimately helping them close more deals. Companies can identify trends, capitalize on opportunities, and assess team performance using straightforward visualization tools. The platform's advanced artificial intelligence enhances its efficiency. Since its inception, Salesforce has continually evolved, adding new features and capabilities. As a result, more organizations trust this platform to improve their efforts.

Let’s examine the advantages and disadvantages of using Salesforce.

Salesforce Development Best Practices for Developers

Here are the top 12 best practices for configuring Salesforce. Force.com is an excellent platform for skilled Salesforce engineers to demonstrate their expertise. To utilize resources efficiently on the Force.com platform, Salesforce has implemented certain restrictions. Therefore, when developing on Force.com, developers should follow Salesforce's Apex coding standards. It ensures a high-quality product. Let's look at the best practices for Salesforce coding.

1. Bulkify your code

Bulkifying Apex code means ensuring the code can handle multiple records simultaneously. When a batch of records triggers Apex code, that code must manage all the documents in the batch. For example, a trigger might be activated when a batch of records is added through the Force.com SOAP API. To create efficient code and avoid hitting limits, all documents in a batch should be processed together if they call the same Apex function.

Poorly written code

The code currently reads only the first Account record in the Trigger, which means it only processes one Account. To fix this, the trigger should be designed to handle all Account records in the Trigger.

Best Practice

This updated version of the code uses a for loop to go through all records in the Trigger—new collection. Now, the trigger can handle all records properly, whether it is used with one Account or up to 200 Accounts.

2. Avoid SOQL Queries or DML statements inside FOR Loops

Salesforce coding guidelines emphasize the importance of processing all incoming records in batches. You should use a for loop to go through all the trigger records and the new collection. A common mistake is to place queries for DML (Data Manipulation Language) statements inside the for loop. There is a governor limit on the number of DML statements that can be executed. When these actions are inside a for loop, they trigger database operations with each loop iteration, which can quickly lead to reaching the governor limits.

Move any database activities outside of the loop. If you need to run a query, do it once to retrieve all the necessary data in a single operation. After that, go through the results. If you need to update the data, gather it into a list and perform the change on that list all at once.

Each Account will be checked individually because a SOQL query is executed within the loop that traverses all account records. A single Apex request can run up to 100 SOQL queries without hitting the limit. If this trigger processes more than 100 Account records at once, it will cause an error.

If you change the 150th contact, you'll exceed the system's operational limit. 

To avoid this, you can update multiple contacts at once. By doing so, you can pull all contact data with one query and perform just one update. 

Now, when triggered by a single account or up to 200 accounts, you only need to run one SOQL query and one update statement.

3. Bulkify your Helper Methods

This coding practice focuses on doing things in bulk, just like the previous one. When you run queries or make changes to the database within a loop, you risk exceeding the system's limits. It applies to any helper or utility methods that an Apex request uses.

Governor limits are set while the program runs. Any Apex code used in that transaction shares these limits, regardless of whether it originates from a trigger, Visualforce page, or another source. If a trigger calls Apex methods from a helper class, those methods should be designed to handle large sets of records. It's essential to develop these methods so they can handle multiple records, particularly if they involve a SOQL query or a DML operation.

When an Apex method runs a SOQL query, it should work with a group of records, such as an Array, List, or Set, to access all data in the Apex transaction. If the method is called separately for each record, it will run queries inefficiently and may exceed the maximum query limit for the transaction. DML statements in Apex methods are handled similarly.

Ensure that you implement any necessary utility or assistance methods to handle record collections effectively. This way, inefficient queries and unnecessary DML operations won't be executed.

4. Using Collections, Streamlining Queries, and Efficient For Loops

Apex collections are essential for querying and storing data in memory. Using collections with streaming SOQL queries can help create effective Apex code and avoid governor limits.

Poorly written code

The primary issue in the example is that opportunity records are checked twice in two consecutive queries. Instead, use the where clause in SOQL to get all the data you need in one query. Another issue is the use of two inner loops that traverse the entire list of opportunity records to identify those linked to a specific account.

Best Practice

This revised version executes a single query for all related opportunities. It features a single inner loop, allowing for the same logic to be applied, making it more efficient and easier to manage.

5. Streamlining Multiple Triggers on the Same Object

When using multiple triggers on the same object, it’s important to reduce duplication and inefficiencies. Redundant actions can happen if triggers operate independently. Remember, when various triggers are active on a single object, it’s crucial to understand how governor limits apply. First, you cannot control the order in which triggers fire. Second, each trigger does not receive its governor limits.

All processed code, including extra triggers, shares the same resources. It means that instead of one trigger getting a maximum of 100 queries, all triggers for the same object divide those 100 queries. Therefore, it's essential to ensure that all triggers function correctly and do not overlap in their respective functions.

6. Large Data Sets Querying

You can get up to 50,000 records from a SOQL query in one request. If your query returns too many records and goes over your heap limit, you need to use a SOQL query for loop instead. This method allows the system to handle multiple batches of documents by using internal calls to query and queryMore.

The example below can cause a runtime error if the results are too large:

Instead, use a SOQL query in a loop, like in the examples below. 

Let the Force.com platform handle significant query results by breaking them into batches of 200 records using this syntax within the loop.

7. Use of the Limits Apex Methods to Avoid Hitting Governor Limits

Limits is a System class in Apex that helps you print debug messages for each governor limit. Each method has two versions: one displays the amount of the resource you’ve used in the current context, and the other, marked with the word "limit", shows the total amount of the resource available for that context.

The example below shows how to add statements in your code to check if you're likely to exceed any governor limits. You can use the System Log or Debug Logs to see how your code performs in relation to these limits. You can also add logic in your Apex code to show error messages before hitting a governor limit. The code example below uses an IF statement to check if the trigger will update too many Opportunities.

Here’s an example of how to combine debug statements with the Limitations Apex class. It helps you get helpful information about governor limits and general code performance.

Below is the output after you run this trigger by updating an account record through the user interface.

• DEBUG|Total Number of records that can be queried in this Apex code context: 10000

• DEBUG|Total Number of DML statements allowed in this Apex code context: 150

• DEBUG|Total Number of CPU usage time (in ms) allowed in this Apex code context: 10000

• DEBUG|1. Number of Queries used in this Apex code so far: 1

• DEBUG|2. Number of rows queried in this Apex code so far: 0

• DEBUG|3. Number of DML statements used so far: 0

• DEBUG|4. Amount of CPU time (in ms) used so far: 9

• DEBUG|Continue processing. Not going to hit DML governor limits

• DEBUG|Going to update three opportunities, and governor limits will allow 10000

• DEBUG|Number of DML statements used so far: 0

• DEBUG|Final number of DML statements used so far: 1

• DEBUG|Final heap size: 1819

When debugging and analyzing the efficiency of your code, the Limit Apex class can be a valuable tool for this purpose. It shows you how to check in advance if you might hit governor limits and suggests better ways to handle those situations.

8. Apex Governor Limit Warning Emails

You can choose someone in your organization to receive email notifications when an end-user runs Apex code that exceeds 50% of any governor limit. To turn on these email alerts, follow these steps:

9. Use @future Appropriately

It is essential to write your Apex code so that it can efficiently handle multiple records simultaneously. Asynchronous Apex methods, marked with the @future keyword, are also impacted by this. You can find an explanation of the differences between synchronous and asynchronous Apex in the section "Governors in Apex Code." Although asynchronous Apex has some higher limits, it still has restrictions. Additionally, you can call a maximum of ten @future methods in a single Apex transaction.

The following is a list of governor restrictions that are special to the @future annotation:

When you use Apex, you can make no more than 10 method calls at a time.

With each Salesforce license, you can make up to 200 method calls in 24 hours.

You must use basic data types, arrays of basic data types, or collections of basic data types as parameters.

You cannot use the future annotation with sObjects or other objects as parameters.

In Visualforce controllers, you cannot use methods with the future annotation in the getMethodName or setMethodName methods, nor in any default functions.

It's essential to call asynchronous methods promptly and keep the code within those methods concise and lightweight. In the example below, the Apex trigger inefficiently calls an asynchronous function for every Account record it needs to process.

Here is the Apex class that defines the @future method

The @future function will run N times because it is inside a for loop that processes accounts. If there are more than ten accounts, this code will cause an error because it exceeds the limit of 10 @future calls allowed in one Apex transaction.

Instead, call the @future function once with a batch of records. This way, it can process all the documents at once.

And now, the @future method is designed to receive a set of records.

Note the small code changes needed to manage a batch of records. It requires less code to handle multiple records than just one. This principle is essential for all your Apex code, whether it runs right away or in the background.

10. Writing Test methods to verify large datasets

When testing Apex code, it’s essential to verify that it can handle large datasets, not just single records. Both user actions in the interface and operations from the Force.com SOAP API can trigger Apex code. The API can send many records at once, causing triggers to activate repeatedly. Therefore, test methods are necessary to confirm that the Apex code is designed to manage larger datasets effectively and that it complies with the system's established limits.

This example illustrates a poorly written trigger that fails to handle large datasets correctly and exceeds system limits. Later, the trigger is improved to manage large datasets correctly.

Here’s an example of a poorly written contact trigger. This trigger runs a SOQL query for each contact to get the related account. The issue with this trigger is that the SOQL query is inside a loop, which means if you insert or update more than 100 contacts, it will hit a governor limit and cause an exception.

Test method for testing whether this trigger correctly handles a volume dataset.

This test method creates a 200-contact array. The trigger will activate when this procedure reaches a governor limit or encounters a system issue, resulting in an exception. This method throws the "Too many SOQL queries" exception because the trigger executes a SOQL query for each contact in the batch. A trigger can only run 100 queries at a time.

It is essential to understand that Test.startTest and Test.stopTest are used in the testing process. Code that runs before and after Test.startTest is subject to different rules than the code that runs between Test.startTest and Test.stopTest. This setup allows you to prepare data without affecting the limits that apply to the code being tested.

Now we will modify the trigger to handle bulk actions correctly. To achieve this, we need to move the SOQL query outside the for loop and run only one SOQL query instead.

This change means that the SOQL query for retrieving accounts is executed only once. If you rerun the test, as mentioned earlier, it will complete successfully with no errors and achieve 100% code coverage.

11. Avoid Hardcoring IDs

Do not hardcode IDs in Apex code when moving it between sandbox and production environments or when downloading packages from the Force.com AppExchange. If the record IDs change between these environments, the logic will correctly identify the correct data to act on, preventing failures.

Here’s an example of a conditional statement that uses fixed record type IDs. It will work well in a development environment, but we cannot be certain that the record type IDs will remain the same if the code is moved to a different organization, such as when included in an AppExchange package.

To effectively manage the changing nature of record type IDs, this example retrieves the record types and stores the data in a map for easy access and retrieval. It avoids using hardcoded values.

By not saving any IDs in Apex code, you make the code more flexible and adaptable. It also ensures that it can be safely shared across different environments.

12. Write one trigger per object to prevent.

If one object has multiple triggers for the same event, the Salesforce system may run these triggers in any order. It can lead to problems if your trigger logic depends on a specific sequence or order for execution to occur.

If an object has three "Before Insert" event triggers, there is no way to be sure which one will run first.

To avoid this uncertainty, it's best to group all the trigger logic for a single event into one trigger per object. 

This practice helps make the code easier to understand and maintain, allowing for simpler future adjustments.

13. Engage in source-driven development

"Source-driven development" is a method that utilizes version control tools, such as Git, within the Salesforce Developer Experience (DX). This approach helps you build and maintain apps on the Lightning Platform. It keeps a record of changes to your system, making it easier for teams to work together. If one developer accidentally deletes another's code, you can still see both the change and the original code. This way, your team can avoid costly mistakes.

14. Create Multiple Sandboxes

Salesforce recommends that developers use separate environments for development, testing, and training. It helps you track each stage of the development process more effectively. By setting specific purposes for each sandbox and determining how often to refresh them, as well as who can access them, you can manage your sandboxes more effectively.

15. Expedite the testing process with automation

Manual testing can be time-consuming, but it is essential to ensure that your Salesforce deployment goes smoothly. You can save time and money by automating the testing process. It helps reduce the risk of human error that comes with manual testing.

• Also Read: Custom Salesforce Development and its benefits

Salesforce Best Practices For Users

Let's examine the best practices for various user types.

• Salesforce Development Best Practices: Executives

• Establish Metrics

• Empower user efficiency with automation

• Make data gathering more efficient.

• Create a plan to support user adoption

• Break down data silos.

Salesforce Development Best Practices: Sales Team

• Segment the market

• Better sales decisions with data analytics

Salesforce Development Best Practices: Administrator

• Never stop learning.

• Be on top of all things cutting edge

• Make the most of Salesforce's reporting tools

Benefits of Salesforce Development: -

• Create easy-to-use applications and features that both technical and non-technical users can navigate with simple drag-and-drop options.

• Add customizable features for different teams and departments to boost productivity.

• Salesforce Cooperation Cloud enhances communication and teamwork by keeping everyone informed about projects and any related issues.

• Develop tools that can answer customer questions, meet their needs, handle comments, and track deliveries to strengthen customer relationships.

• Maximize the potential of built-in analytics to create reports that forecast business growth, track competitors or market trends, and evaluate brand reputation.

• Ensure Salesforce works smoothly with existing systems and applications to enhance overall business performance.

Best Practices De-Coded: -

1. Develop a Complete Plan – Without a clear plan, achieving success is difficult. It’s essential to have a strategy that outlines how you will create and implement your solution before initiating the Salesforce development process. Planning helps you visualize your current position, your future goals, and the steps required to achieve those goals.

2. Uncover the finer nuances of Salesforce Architecture. After creating a plan, it’s essential to understand how Salesforce works. It includes the various layers, their interactions, and the different components, APIs, and databases involved. You should also be familiar with the platform's key features and the pre-packaged applications that run on it. Finally, it's essential to understand how data and communication flow between the different servers.

3. Explore and Exploit The Test Environment. Salesforce allows you to develop modules and customize features in a live environment; however, it's recommended to use the sandbox for development. Using the sandbox prevents any impact on your system's performance. You can choose from three types of sandboxes: a developer sandbox for creating new features, a partial sandbox to see how development changes may affect your system, and a full sandbox to implement customizations and test how they work in your system.

4. Ensure Consistency in Coding - Having multiple developers working on a Salesforce project simultaneously is common. To make the development process easier, it’s essential to follow a consistent coding style. Using standard coding rules helps create clear guidelines and ensures that everyone on the team understands and follows the same standards and practices. This consistency enables all team members to make similar decisions and work effectively together.

5. Utilise Salesforce's built-in Trigger Frameworks - Using trigger frameworks can significantly save time and effort in software development, especially as your needs grow. They help eliminate complicated logic and ensure consistency throughout the platform. It makes unit testing, integrating changes, and maintenance much easier. Once standardized, you can trust that all your triggers function consistently, providing you with complete control over the order of operations.

6. Embrace a Modular Approach to Your Salesforce Development. One of the key benefits of Salesforce development is the ability to create functions or modules independently of each other. By using a modular approach, you can design the system so that each part can be improved separately. This way, if one part fails, it does not affect the other processes.

7. Deploy Appropriate Tools - To develop your Salesforce platform effectively, start by choosing the right features and tools. It will help you begin testing as soon as possible. Analyze the tools you have and think about your needs. Select the ones that will help you work more efficiently.

8. Refrain from DML/SOQL Queries - Sometimes, you may want to add or update multiple records at once and search through documents based on specific situations. While looping through the forms, you may feel tempted to run a query or update the records. But be careful—this can lead to problems.

   • Both SOQL and DML are expensive operations in Salesforce Apex. Because of this, there are strict limits on how many times you can use them. Placing these operations in a loop can cause problems, as you can quickly hit these limits, especially when working with triggers.

   • When dealing with DML statements, it's better to move these statements outside of loops. Instead, we can gather the records we want to work with in a list within the loop and then apply the DML statement to that list. This approach is often the best choice. However, moving SOQL outside of a loop can be more challenging because it depends significantly on the specific situation.

9. Only Hard-Code IDs When Needed - When IDs are hardcoded, they may work well during development. However, once we move the code to production, those IDs might no longer point to the correct records. It is especially true for Record Types that were created in a sandbox and then moved to a production environment. In the opposite case, if we make a sandbox from production, our hard-coded IDs will no longer match the correct records.

• We can use record types by referring to their Developer Name, which stays the same in all environments. If we want to use a specific ID linked to a record, we can store this ID in our custom metadata. Then, we can retrieve the value while the code runs. It lets developers change the value based on the environment or specific requirements.

• We do not need to follow the two methods mentioned earlier when we refer to the Master Record Type. This record type is the default and remains unchanged across all instances. However, just because it is currently fixed does not mean it will always be that way. We should consider storing it in custom metadata if needed.

10. Declare Openly the Existence of a Sharing Model - When we start writing new code, the first thing to do is define how we will share it. It is essential. If we want our code to follow sharing rules, we must clearly state that. However, if we want to skip record access, we need to specify that it is not shared. Many developers overlook this step.

• Being transparent about how we share our code helps us explain our goals to anyone who might work on it in the future. If we don’t state this, it will be harder for them to understand the code. However, if we include this information, they will find it much easier to grasp what’s happening.

• You can skip declaring the sharing model only if your code does not do any DML (Data Manipulation Language) operations or queries. It is the only time it is safe to omit it. However, if there is a possibility of DML or if you want to be cautious, it is better to declare the sharing model as 'inherited.' This way, the user of your course can control the model. Declaring it like this helps you stay on the safe side.

11. Use Only One Trigger Per Single Object Type - Many programmers believe in using just one trigger for each object. This principle is easy to remember and simple to apply. But why is this "best practice" so important?

• When you have multiple triggers set up on one object, you cannot be sure of the order in which they will run. When a record is saved and the triggers activate, their execution order is random. It's common for the actions within a trigger to have their priorities or conditions that require one action to finish before another can start. For example, if you need to assign a parent lookup, it must be done before the following action that relies on it can proceed.

• Using a completely random order for triggers adds unpredictability to our code. This randomness makes it harder to debug and develop, as it is challenging to reproduce specific situations easily.

12. Test Multiple Scenarios - When testing code, achieving high test coverage is essential, but it’s not everything. Salesforce requires that you have at least 75% code coverage before deploying Apex code to production.

• You write tests to show that your code has been used, without adding any real value. These tests only prove that your code works in specific situations, but they may fail when used in real-life scenarios.

• When we write tests for our code, we should focus less on code coverage and more on testing various use cases. This approach helps us protect the situations where our code runs. We achieve this by writing multiple test methods. Some of these methods may test the same code without adding new coverage lines. Each test method runs our code under a different scenario, which helps us test the system effectively.

• One way to use this is to test both successful and unsuccessful scenarios in a trigger. After running the tests, the next step is to verify that the code has performed as intended. If it hasn’t worked, we will manually fail the test. If the code doesn’t perform correctly, we will also manually delete the test.

• Testing our code is essential for more than just checking code coverage. It also helps us identify problems early, particularly when new features are added or when parts of the code are modified. This type of testing alerts us to issues before they reach production, preventing late nights spent fixing them. Additionally, it helps us find ways to save money by addressing potential problems early.

13. Double Check Tests - The quality of your Salesforce solution depends on how much testing you do. You need to test the platform’s features to make sure it meets your client's daily needs. Check every function you've created to ensure it works correctly in all situations.

14. Keep Documentation Clean and Complete - When creating a solution for Salesforce, it's essential to document everything programmers are working on. It helps avoid misunderstandings. Keeping a log of all development efforts helps other administrators and developers understand what has been done. It also prevents those changes from being duplicated or modified when they shouldn't be.

15. Avoid Business Logic In Triggers - When we write triggers, it becomes hard to test and maintain the logic if we put it directly in the trigger. Instead, we should use classes that handle our logic. These classes are easy to test, manage, and reuse. We often call these classes TriggerHandlers.

• These TriggerHandler classes take input from the trigger and then call the specific courses that contain our business logic. Updating these handlers can be simple, such as naming the new code we add, or complex, involving the use of custom metadata types. It allows admins to configure our triggers in different ways.

• It is essential not to embed your logic and functionality directly in a TriggerHandler or TriggerHelper class. Doing so can lead to unexpected results. Instead, create separate categories for each piece of functionality. The TriggerHandler should call these classes.

• If we don’t follow this procedure, we will quickly create code that is hard to maintain. It violates the "Single-Responsibility Principle" because it consolidates all aspects of an object's actions into a single location, resulting in a "God object," which is a poor practice.

• If an object's trigger is effortless (for example, if it only calls one action), it might be fine to skip a handler class. Instead, you can directly contact the action from the trigger itself. However, you should plan your steps as if you are using a handler. Once the trigger becomes more complex, move those steps to a handler.

  • Also Read: Strategies for hiring exceptional Salesforce Developers

Summary

Using industry standards and best practices is crucial for any solution provider. To achieve great results with your Salesforce development projects, it's essential to understand the underlying principles of the development process and what it entails. This understanding will enable us to make more informed decisions about the short-term and long-term consequences of our choices.

This article covers key Salesforce best practices. To write efficient and scalable code, you should apply these ideas to your Apex code. First, handle all incoming records simultaneously rather than one at a time. Avoid running SOQL searches in a loop to stay within governor limits. The article also provides examples of useful debugging statements for governor limits and other important Salesforce development tips. By following these guidelines, you will improve your success with Apex programming.

Ready to implement Salesforce development best practices that drive results?

At Codleo Consulting, we offer expert-led Salesforce development services tailored to your unique business needs. As a trusted Salesforce partner, we help you build scalable, high-performing solutions backed by years of experience and industry knowledge. Let’s turn your ideas into impactful Salesforce solutions.

Schedule a free consultation call.