The Salesforce Platform Developer 2 certification is a credential developed for Salesforce professionals who have experience in implementing advanced programmatic solutions on the Salesforce platform and are looking to verify their expertise.

In Platform Developer 2, there are 5 topics covered. The topic with the highest weighting is Process Automation, Logic, and Integration. As it is weighted at 24%, this is an area that you must focus on to do well in the exam.

The following are the core topic areas of the Salesforce PD2 certification and what you’re expected to know:

This section covers multiple types and capabilities of base-system objects and their use cases and considerations when working with these objects. Salesforce allows accessing these objects programmatically using Apex, SOQL, or Salesforce APIs, which are some of the tools that can be used to build custom functionality into the platform. Salesforce provides a number of features as well for creating and enabling apps to handle multiple languages, currencies, and locales.

An effective platform developer must be able to determine when to use declarative configuration, implement low-code solutions, or resort to programmatic customization for meeting business requirements. The declarative features as well as high-level overview of the capabilities of the different automation tools such as workflows, approvals, processes, and flows are discussed in this section. Simple and complex scenarios involving business requirements are presented that help identify which tools can be used and when to involve programmatic solutions.

Additionally, one must be familiar with a variety of topics related to data management. Apex managed sharing is one of three sharing capabilities in Salesforce and uses Apex to manage the sharing of a record between users or groups. While managed sharing access is granted by the system based on record ownership, role hierarchy, and sharing rules, user managed sharing, which is also known as manual sharing, allows the record owner or any user with Full Access permissions to a record to share the record with a user or group of users. In situations where neither managed nor user-managed sharing is suitable, Apex managed sharing can be used in order to build complex and dynamic sharing settings that are otherwise not possible via standard configuration.

External IDs are primarily used to import data from external systems and for integrating external system data into Salesforce. They allow Salesforce developers and admins to maintain data relationships between internal and external objects. External lookup and indirect lookup relationships use external IDs for matching records.

Custom settings and custom metadata types are used to store values which do not change frequently but need to be frequently referenced in Salesforce. The data from custom settings and custom metadata types is pulled into the application cache which allows for efficient access of the data and, in most cases, does not count towards the SOQL limit. Both approaches support many different data types. Referencing custom settings and custom metadata types in business logic makes customizations easier to maintain and read, and reduces the number of places where changes need to be made. Custom metadata types are a newer concept and are preferred over custom settings in many cases. However, there are scenarios in which custom settings are still the preferred approach.

The Process Automation, Logic, and Integration section covers in detail both the declarative and programmatic aspects of customization and development in the Salesforce platform. A Salesforce developer is expected to determine when to build declarative or programmatic solutions based on given requirements. The interactions between the different tools are also discussed in this section. For example, Apex code can be invoked from a process or flow. A flow can be launched from a Visualforce page or custom Lightning component, or it can be invoked from Apex or a process. A process can also be invoked by another process. This knowledge allows developers to be able to choose the right and effective combination of features whenever tools need to interact with each other in a provided solution.

Salesforce offers two programming models for developing Lightning components - Lightning Web Component and Aura Component. When developing these components, one should know the server-side requirements as well as the different methods for invoking Apex methods and handling their output in the client-side application.

Efficient Apex triggers are necessary to ensure scalability and avoid limit exceptions caused by exceeding governor limits. Exceptions denote errors in code, which can be handled in general by using assertions, returning error codes, and implementing exception handling. Standard as well as custom exception types can be used to handle different types of errors. This helps to ensure transactional integrity by throwing exceptions and terminating code execution before committing database changes.

The Salesforce Object Query Language (SOQL) is used for querying records in the Salesforce org database. SOQL can be used when the location of the data is known and can be executed from different environments such as in Apex, Developer Console, Visual Studio Code, or Salesforce CLI. A developer should be able to identify the different SOQL keywords and how to use them in a query.

Salesforce provides features that enable Apex transactions to be executed asynchronously as well. Future methods, queueable Apex, batch Apex, and scheduled Apex enable Apex code to be run asynchronously. A developer should be able to determine their capabilities, best practices, considerations, and when to use them in a given requirement.

Finally, metadata information about sObjects and fields can be obtained dynamically and used in Apex code. Tokens or a Schema method can be used to obtain “describe information” pertaining to sObjects. Information about apps and tabs can also be obtained using dynamic Apex. Dynamic SOQL or SOSL query can be created and used in assignment statements and FOR loops in Apex code. Moreover, Apex also allows creating sObjects dynamically and inserting them into the database.

In this section, one is expected to be knowledgeable in developing applications using the different user interface components available in the Salesforce platform. For example, in Lightning web components and Aura components, certain server-side requirements must first be met before an Apex controller can be used. It is important to identify the necessary changes in the Apex class for it to receive requests and return data to the client-side component accordingly.

Visualforce pages can be set as the target of a custom button or link, or buttons on the pages themselves can be used to perform custom actions. This is made possible using a combination of Visualforce tag attributes and methods in the associated controller. Asynchronous events are supported in Visualforce and can be performed using a number of options. The reRender attribute, for example, can be used to execute partial page updates. Visualforce tags such as actionPoller, actionSupport, and actionFunction are used to perform asynchronous operations.

When developing user interfaces, one important consideration is proper error handling and effective messages presented to users when errors are encountered. Visualforce, Lightning, and JavaScript provide mechanisms for displaying error messages. A developer should be familiar with the techniques and best practices and take advantage of the built-in error handling framework to provide better user experience in applications.

Visualforce and Lightning frameworks are two options that allow developers to build custom user interfaces or pages, create or extend functionality in the UI, develop components or standalone apps, integrate third-party platforms, and much more. Visualforce is page-centric, which refers to a web application model that fundamentally relies on the server to generate a new page when a user interacts with the application. Lightning uses the app-centric model and relies on client-side Javascript to create, modify, transform and animate the user interface instead of generating a new page in response to a user request.

Performance is a very important attribute and benchmark in any application. This section describes common application performance issues and methods to mitigate their impact. A slow-loading or slow-refreshing page is aggravating for end users and reduces their productivity.  Applying specific coding best practices both on the client-side and server-side can dramatically improve application performance.

An effective developer should be able to identify, locate, and resolve inefficiencies. Inefficient Apex code examples and the best practices for mitigating negative impact are discussed. One of the most common consequences associated with inefficient code is exceeding governor limits. Various mitigation techniques are described here to avoid hitting governor limits to help build a robust and scalable application. Moreover, Apex also provides the functionality to output debug messages related to governor limits, which is also covered here.

In practice, applications that involve Apex perform queries to the database using SOQL or SOSL. Poorly designed queries impact application performance. Hence, there are certain methods available to make efficient transactions with the database. For example, using selective queries, which require filters based on indexed fields, maximizes the performance of applications that use them. Skinny tables and divisions can also be used to improve query performance. The complexity of a query also affects its performance. When designing application logic, certain steps can be taken to ensure that performance is optimized, such as reducing the number of DML operations and SOQL queries. Using asynchronous callouts in Apex also improves the performance. A long-running callout using the Continuation class can be used to execute callouts to an external system asynchronously to ensure that they do not count toward the Apex limit of ten synchronous requests that last longer than five seconds. A future method can be used to perform an asynchronous callout in an Apex class, for example, when a user is not required to wait for a response from the external system after sending the request.

One of the best practices in programming in general is code reuse and offers great benefits in application development, performance, and maintenance. Apex code can be reused in other Apex classes & triggers, Visualforce pages, Aura and Lightning web components. A helper class with reusable methods can be created and shared by different applications. Custom controllers can also be reused in Visualforce pages and Lightning components, provided they require the same functionality. 

Testing is a required process in any application involving Apex code. This section discusses how to create and execute unit test classes for testing Apex classes and triggers. Unit tests should be created to achieve the 75% minimum code coverage required for deployment, but developers should write test methods for all possible test cases. Test data can be created for testing. A method annotated with @testSetup provides an easy way to create test data for all methods in a single test class. Test utility classes and test data stored as static resources allow for easy reuse of test data across test classes. Web service or Http callouts cannot be tested directly, but Salesforce offers mock interfaces, which can be used to simulate their callouts.

There are various techniques and tools that one can use to test Apex classes and triggers, Visualforce controllers, and controller extensions. Several conceptual scenarios are discussed to determine the changes that are required to resolve issues in Apex tests that are not performing as expected. Since Visualforce controllers and controller extensions are Apex classes, they should have code coverage to ensure total code coverage is at least 75%.  Because controllers and extensions are designed to work with pages visible to end users, some special coding is required in their test classes to simulate user input from the page. The techniques and tools that are used when testing Visualforce controllers and controller extensions are covered. Aside from server-side code, Lightning web components and Aura components can also be tested. The Jest testing framework can be utilized to test Lightning web components. The Lightning Testing Framework (LTS) can be used to test Aura components.

Salesforce provides and recommends tools and techniques for analyzing Apex code or triggers when data and performance issues are encountered. The available methods, procedures, and considerations when troubleshooting are discussed. One of the most common causes of performance issues are inefficient queries, callouts, and DML statements causing cascading updates. Identifying which particular process is causing problems frequently involves the use of debug logs which, when viewed with the right tools, can provide valuable insights into performance bottlenecks. Performance analysis typically begins on the client-side with the help of tools, such as ChromeDeveloper Tools, and continues to the server-side where debug logs and SOQL queries can be analyzed.

Salesforce provides tools that allow developers to deploy changes from one environment to another. Depending on the scenario, or phase in the deployment process, a particular tool is needed to perform a certain task. The deployment process and its supporting tools, as well as the deployment options to use in a given scenario are covered.

JavaScript programming knowledge is required in order to build Aura components and Lightning web components. A platform developer should not only be familiar with identifying and resolving server-side issues but also in handling errors on the client-side. JavaScript code snippets are provided in this section to illustrate concepts that a developer should be aware of when writing JavaScript code. Understanding how JavaScript responds to errors and the features available techniques for handling these errors helps build robust and secure applications on the Salesforce platform.