SF-PD2 Advanced Developer Fundamentals — 20 Questions

Question 1

A developer needs to implement a custom logging framework that persists logs even if the primary transaction fails. Which approach ensures the logs are committed independently of the main transaction?

Accepted Answer

Invoke an @future method to perform the DML operation for logging.. Using the @future annotation or Platform Events allows decoupling the logging logic from the main transaction. Since these processes run in a separate transaction context, they remain independent of the caller's success or failure. This architectural pattern is crucial for audit trails and debugging, ensuring that critical diagnostic information is captured and persisted regardless of whether the primary business logic encounters a fatal DML exception.

Answer

Call a public method in a static Utility class using standard DML.

Answer

Implement a Queueable interface and pass it to System.enqueueJob within a Savepoint.

Answer

Utilize a Platform Cache session cache to store logs before flushing them.

Question 2

Refer to the exhibit. The developer is attempting to optimize a query for a large Contact dataset. Why does the provided query fail in the context of advanced Apex development?

Accepted Answer

The developer is incorrectly using an aggregate function within the filter criteria.. The query fails because of a misunderstanding of SOQL limitations regarding cross-object references and filtering. While the query syntax looks valid for standard lookups, complex filtering involving aggregate fields or specific cross-object conditions can trigger unexpected exceptions if the underlying data model has circular references or if the developer attempts to filter on fields that are not indexed or are calculated via unsupported formulas.

Answer

The query attempts to filter on a field that is not indexed in the schema.

Answer

The query contains an invalid reference to the Account object in the WHERE clause.

Answer

The Email field is not supported for filtering in the WHERE clause.

Question 3

A developer wants to prevent duplicate records from being inserted into the database. Which method is most efficient for high-volume data operations?

Accepted Answer

Using a Database.DMLOptions instance with DuplicateRuleHeader set to allow.. Using the Duplicate Management feature via the DML Options class during insertion is the most robust and efficient way to handle duplicates. It leverages Salesforce's native matching and duplicate rules, which are optimized at the platform level. This approach is superior to manual query-based checks because it offloads the complexity of fuzzy logic and threshold matching to the platform's native engine.

Answer

Querying for existing records before every DML statement.

Answer

Implementing a custom Apex trigger that uses regular expressions for matching.

Answer

Enabling 'Unique' on all fields involved in identification.

Question 4

Which THREE practices are considered best for maintaining high performance when using custom Apex triggers?

Accepted Answer

Utilizing a single trigger per object and delegating logic to handler classes.. Apex triggers should remain lightweight to ensure scalability and avoid hitting Governor Limits. Following these patterns ensures that the trigger is not only performant but also maintainable and extensible. By centralizing logic and minimizing DML operations, developers prevent the common pitfalls of recursive execution and excessive consumption of system resources in high-volume environments, which is critical for PD2-level excellence.

Answer

Performing DML operations inside a FOR loop for each record.

Answer

Adding logic to automatically resolve all recursion issues via DML options.

Question 5

Refer to the exhibit. The batch process is failing with a SOQL limit exception. What is the most likely cause within the context of a batch implementation?

Accepted Answer

The trigger does not correctly bulkify its SOQL queries.. The LimitException occurs because the developer likely placed a SOQL query inside the execute method's loop, or the trigger is performing queries for each record individually. In batch apex, the execute method processes a list of records. If the trigger logic is not bulkified, the combination of multiple batches and the trigger overhead causes the cumulative query count across the entire transaction to exceed 100 queries.

Answer

The batch size is too small, causing too many total transactions.

Answer

The Batch class is missing the Database.AllowsCallouts interface.

Answer

The governor limits for Batch Apex are different from standard Apex.

Question 6

What is the primary benefit of using a Custom Metadata Type over a Custom Object for configuration data?

Accepted Answer

They do not consume SOQL governor limits when queried.. Custom Metadata Types are deployable as part of the package metadata, meaning the configuration travels with the application. Furthermore, they provide the ability to access data via SOQL without consuming query limits. This makes them ideal for application settings, mapping tables, or static configuration data that needs to be consistent across environments while keeping runtime query execution counts low, which is vital for high-performance enterprise applications.

Answer

They allow for the creation of relationships to standard objects.

Answer

They support the same security and sharing model as custom objects.

Answer

They can be modified at runtime by end users through standard pages.

Question 7

A developer needs to implement a custom search mechanism for a large dataset that includes fuzzy matching on multiple text fields. Which index strategy or tool is most appropriate?

Accepted Answer

Utilizing SOSL (Salesforce Object Search Language) for the search operation.. For complex, multi-field fuzzy searching on a large dataset, standard indexing or SOQL queries are often insufficient. Einstein Search or SOSL (Salesforce Object Search Language) are designed for search functionality. SOSL provides powerful, platform-optimized search capabilities across multiple objects and fields simultaneously, making it the standard choice for building robust search interfaces within Apex that outperform standard SOQL filtering.

Answer

Creating custom indices on all searchable fields.

Answer

Querying all records into a list and filtering in memory using Apex.

Answer

Using a combination of nested SOQL subqueries.

Question 8

Which Apex feature allows a developer to ensure that a block of code runs with the permissions of the user who created the class, rather than the user currently invoking it?

Accepted Answer

Declaring the class using the 'inherited sharing' keyword.. The 'with sharing' or 'without sharing' keywords are foundational to Salesforce security. 'Without sharing' (or the default behavior in some contexts) ensures the code ignores the current user's sharing rules, while 'with sharing' enforces them. However, to explicitly handle a scenario where a class runs with the permissions of the class author, the 'inherited sharing' keyword is the modern standard, ensuring proper security context propagation.

Answer

Using the @SystemAdmin annotation.

Answer

Declaring the class using the 'without sharing' keyword.

Answer

Setting the class security level to 'Public'.

Question 9

Which TWO statements are true regarding the behavior of 'static' variables in Apex?

Accepted Answer

Static variables persist for the duration of a single execution context.. Static variables are scoped to the transaction. They are initialized when the class is loaded and persist throughout the entire request execution. Understanding this lifecycle is critical for optimizing performance (e.g., caching) and for preventing bugs related to state persistence across trigger executions within the same transaction. These two statements correctly identify the scope and persistence of static variables in the Apex runtime environment.

Answer

Static variables retain their value across different transactions.

Answer

Static variables are stored in the database for future reference.

Answer

Static variables are thread-safe by default in Salesforce.

Question 10

A developer needs to perform a DML operation that bypasses all validation rules and trigger logic for a specific data migration. Which method is most appropriate?

Accepted Answer

Using a static flag pattern to conditionally skip trigger logic.. Standard DML cannot bypass trigger or validation logic. To achieve this, the developer must use the Database.insert(record, dmlOptions) pattern where the DMLOptions are configured to specifically ignore rules. However, the most robust, platform-supported way to bypass triggers in specific programmatic scenarios is by using a combination of a static flag in a helper class and explicit trigger logic to check that flag before execution.

Answer

Using a System.runAs() block to run as a user without permissions.

Answer

Using the 'disableAllRules' parameter in Database.insert.

Answer

Deleting the validation rules before the DML and recreating them.

Question 11

A developer needs to implement a custom logging framework that persists logs even if the primary transaction rolls back due to a DML exception. Which approach satisfies this requirement?

Accepted Answer

Invoke an @future(callout=false) method to handle the log record insertion.. To persist logs independently of the main transaction, developers must use the 'without sharing' keyword and trigger a separate transaction using the @future annotation or Platform Events. By decoupling the logging operation, the system ensures that the log record DML is committed to the database regardless of the success or failure of the preceding operations in the calling transaction, which is critical for auditability in complex integrations.

Answer

Use a static class with a static list to buffer logs and insert them in a finally block.

Answer

Use a Platform Event and ensure the publishing transaction is set to 'Publish Immediately'.

Answer

Perform the log insertion using an 'after insert' trigger on the object being processed.

Question 12

A developer is optimizing a complex Apex process that processes large volumes of Account records. Which TWO strategies effectively reduce the likelihood of hitting the 'Apex CPU time limit'?

Accepted Answer

Replace nested loops with Map-based lookups.. Reducing CPU time is essential for large-scale Apex processing. By optimizing algorithmic complexity and offloading logic to the database or asynchronous processes, developers stay within the 10,000ms limit. Efficient use of maps and selective queries prevents unnecessary iterations over large collections, which is the primary driver of high CPU consumption in Salesforce environments.

Answer

Increase the batch size in the Batch Apex class.

Answer

Move data processing logic to an asynchronous @future method.

Answer

Use the 'System.debug' statement to track execution time for every method.

Question 13

A developer is writing a Unit Test for a service class that performs DML on a custom object with a complex validation rule. The test fails because the validation rule prevents the record from being inserted. What is the best practice to ensure the test passes while maintaining code coverage?

Accepted Answer

Construct the test data to include the fields required by the validation rule.. Unit tests should be isolated and test specific business logic. By utilizing the 'Test.startTest()' and 'Test.stopTest()' blocks, developers can manage governor limits. However, to handle validation rules, the test must populate the fields in a way that satisfies the criteria. This ensures the data is valid while still allowing the developer to test the application's response to both valid and invalid data states.

Answer

Use 'System.runAs' to bypass all validation rules.

Answer

Disable the validation rule via Metadata API during the test setup.

Answer

Mock the object using a custom interface.

Question 14

A developer is tasked with handling highly sensitive PII data within Apex. Which THREE security best practices must be implemented to ensure data compliance?

Accepted Answer

Use 'WITH SECURITY_ENFORCED' in all SOQL queries.. Securing PII in Apex requires a defense-in-depth approach. By enforcing FLS, using shared-safe queries, and ensuring data is handled in memory without storage where possible, developers protect against unauthorized access and injection attacks. These practices are essential for compliance with global privacy regulations and Salesforce security standards for high-security applications.

Answer

Use 'without sharing' on all classes to ensure data is always accessible.

Answer

Encrypt all data in the database using Apex encryption.

Question 15

A developer needs to ensure that an integration user can update specific fields that are read-only for standard users. Which tool or technique should be used?

Accepted Answer

Use a Permission Set with the 'Edit Read-Only Fields' permission.. The use of a Permission Set with 'Edit Read-Only Fields' enabled is the standard approach to grant elevated access to a specific service user. This maintains the principle of least privilege while allowing the integration to function correctly. This is preferred over using an Apex 'without sharing' class, which is a broader security escalation.

Answer

Use a trigger that runs as the System user to overwrite the fields.

Answer

Create a class with 'without sharing' to bypass field security.

Answer

Change the Field-Level Security for all users to 'Edit'.

Question 16

Which statement best describes the execution order when a DML operation is performed on an object that has both a custom validation rule and a duplicate rule?

Accepted Answer

Validation rules always run before duplicate rules.. The Salesforce execution order is strictly defined. Validation rules are always evaluated before duplicate rules. If the record fails validation, the process terminates immediately, and the duplicate rules are never invoked. This ordering ensures that the database only attempts to evaluate complex duplicate logic on data that is already syntactically and logically valid.

Answer

Duplicate rules run first, followed by validation rules.

Answer

Both rules run in parallel on separate threads.

Answer

The order is non-deterministic and varies by system load.

Question 17

A developer needs to store configuration settings that are accessible globally in Apex code without making repeated SOQL queries. What is the most efficient pattern to implement?

Accepted Answer

Use a Custom Metadata Type and access it via 'getInstance()'.. Custom Settings or Custom Metadata Types are the preferred ways to store configuration data. Custom Metadata Types are superior for global settings because they are cached, do not count against SOQL limits, and can be packaged. Accessing these via the 'getInstance()' method provides an O(1) performance profile, ensuring that configuration is retrieved instantly without hitting the database in every transaction.

Answer

Store settings in a static variable in a utility class.

Answer

Create a custom object and query it in the constructor of every class.

Answer

Hardcode the settings in a constant class.

Question 18

Which THREE features are specific capabilities of Platform Events that distinguish them from standard SObject DML transactions?

Accepted Answer

The ability to integrate with external systems via CometD.. Platform Events enable event-driven architectures that are decoupled from the main transaction. They allow for asynchronous processing, integration with external systems, and a publish-subscribe model that doesn't hold locks on core Salesforce data. These features provide the scalability and reliability required for high-volume integrations, which standard DML-based approaches cannot achieve without significant performance and concurrency trade-offs.

Answer

Automatic transaction rollback if the subscriber fails.

Answer

Guaranteed delivery order regardless of the subscriber type.

Question 19

Which pattern should be used to ensure that a long-running Apex process does not block the user interface while performing complex calculations?

Accepted Answer

Implement a Queueable class to process the request asynchronously.. For long-running tasks, the 'Apex Controlller' approach is insufficient because it is synchronous and bound by the request timeout. Using a 'Queueable Apex' or 'Batch Apex' pattern allows the work to be offloaded to the background. By providing a status polling mechanism, the UI remains responsive, and the user can see the progress of the operation without waiting for the server to finish execution.

Answer

Use the 'future' annotation to call the process synchronously.

Answer

Use a standard Controller with 'action' polling.

Answer

Execute all logic in the constructor of the Visualforce controller.

Question 20

A developer needs to implement a custom interface to be used by multiple service classes. Which approach ensures the highest level of reusability and maintainability?

Accepted Answer

Use a Factory pattern to return an object type that implements the interface.. Defining an Interface defines a contract that classes must implement. By using the 'implements' keyword, service classes can be polymorphic. This allows a calling method to treat different service implementations interchangeably, provided they follow the interface. This architecture is essential for large systems where different implementations might be needed for different business units or countries, without changing the core business logic.

Answer

Use a virtual base class and override methods in child classes.

Answer

Define the logic in a static utility class instead of an interface.

Answer

Use a dynamic Apex 'Type.forName()' call to instantiate classes.