Salesforce Certified Platform Developer II Exam Dumps & Practice Test Questions
A developer is troubleshooting a Visualforce page that experiences significant load delays because it attempts to display a large dataset at once.
To improve the page’s performance, which of the following strategies should the developer apply?
A. Shift data processing to the browser using JavaScript instead of the Apex controller
B. Declare List variables as transient in the custom controller
C. Implement lazy loading so data loads only when needed, not in the constructor
D. Use an <apex:actionPoller> to asynchronously load all the data in intervals
Correct Answer: C
When a Visualforce page loads slowly, especially due to large volumes of data being rendered initially, developers must consider optimization techniques that reduce unnecessary data processing. One of the most effective and widely recommended techniques for this scenario is lazy loading.
Lazy loading is a design pattern that involves loading data on demand—only when it is actually needed, rather than all at once during the page initialization. In Salesforce Visualforce development, this usually means deferring the retrieval of data until a user triggers it—such as by clicking a “Load More” button or navigating through pagination. This is typically accomplished using Visualforce components like <apex:actionFunction>, <apex:commandButton>, or <apex:actionSupport> combined with Apex methods.
By avoiding the retrieval of all data in the controller’s constructor, lazy loading minimizes the work done during the initial page rendering. This leads to significantly faster load times and a better user experience. It's also scalable and respects governor limits better by loading only subsets of data as needed.
Option A: Moving processing logic to JavaScript shifts the computational burden to the browser, but it does not solve the core problem—initial data retrieval. The data still needs to be loaded first by Apex before JavaScript can process it.
Option B: The transient keyword in Apex helps reduce view state size but does not impact initial data loading. It only prevents variables from being serialized between requests, which is unrelated to the page’s slow initial rendering.
Option D: The <apex:actionPoller> is useful for real-time updates or periodic refreshes (e.g., dashboards) but is not designed for managing large datasets. Using it to asynchronously load data can result in excessive server calls, potentially degrading performance further.
To address performance issues related to heavy data rendering, lazy loading offers a targeted, scalable, and efficient solution. It aligns with Salesforce's best practices and ensures that the page performs optimally without overwhelming system resources or users.
Universal Containers is building a Customer Community using Customer Community Plus licenses. Their customers are large enterprises with complex account hierarchies—each with multiple departments represented by separate Account records. These community users need to see rented container records across multiple departments, and access control is based on a custom junction object that links Contacts to various Accounts.
Which solution best enables users to access the appropriate container records across departments?
A. Use a Visualforce page with a custom controller marked as “without sharing”
B. Create a Custom List View on the junction object filtered by record owner
C. Develop a Custom Report Type and add a report to the Community Home Page
D. Use an Apex Trigger to create Apex Managed Sharing based on the junction object
Correct Answer: D
The challenge described involves enabling complex record-level access for Customer Community Plus users across multiple Account hierarchies, governed by a custom junction object. In Salesforce Communities (especially with Customer Community Plus licenses), sharing rules must be explicitly enforced to ensure secure and controlled access.
Standard sharing mechanisms like role hierarchy or sharing rules cannot adequately address many-to-many relationships derived from junction objects. This calls for a programmable solution—and the most robust method available in Salesforce is Apex Managed Sharing.
Apex Managed Sharing allows developers to programmatically create sharing entries (e.g., CustomObject__Share records) that grant specific users access to specific records based on complex logic—exactly what is needed here. By writing an Apex Trigger on the junction object, Universal Containers can dynamically evaluate which users should have access to which container records and create the necessary sharing entries accordingly.
This approach is secure, scalable, and fully compliant with Salesforce’s sharing model for communities.
Option A: Using a Visualforce controller with “without sharing” bypasses the built-in sharing model. This might expose sensitive data to unauthorized users and is not secure, especially in a community context where strict access controls are essential.
Option B: Custom List Views only display records the user already has access to. They do not override or extend sharing settings, making them ineffective for this case.
Option C: Reports also respect existing sharing rules. If a user doesn’t already have access to a container record, the report won’t show that data. Reports cannot grant access—they merely reflect it.
To achieve the desired outcome—granular sharing based on complex, custom relationships—Apex Managed Sharing is the only method that provides the required flexibility and control. By using an Apex Trigger to dynamically assign access based on the junction object’s data, Universal Containers can confidently enforce the right visibility across their global customer base.
Universal Containers plans to validate shipping and billing addresses using an external web service. The current integration uses basic authentication, but the company may switch to another service provider using OAuth.
How can they support this change in authentication method without having to alter their integration code?
A. Custom Metadata
B. Custom Setting (List)
C. Dynamic Endpoint
D. Named Credential
Correct Answer: D
Explanation:
When integrating with external web services in Salesforce, flexibility and security in managing authentication are crucial—especially when the authentication mechanism might change. In this case, Universal Containers needs a solution that supports multiple authentication methods (e.g., Basic Auth and OAuth) and allows seamless vendor switching without altering Apex code.
The most appropriate Salesforce feature for this scenario is a Named Credential. This feature allows developers to define external service configurations—including the endpoint URL and the authentication method—in a declarative and secure way within Salesforce Setup.
With Named Credentials, the system handles the authentication details automatically during callouts. Developers can simply reference the Named Credential in their code (e.g., using callout:My_Named_Credential) and avoid embedding credentials or handling authentication manually in Apex. This enables significant code reuse and minimizes the risk of exposing sensitive data.
Let’s examine the alternatives:
Custom Metadata: Useful for storing static configuration data such as endpoints, field mappings, or constants. However, it lacks native support for authentication protocols. To use it for managing credentials or tokens, developers would have to write custom code, which violates the requirement of avoiding code changes during vendor transitions.
Custom Setting (List): Similar to custom metadata, this option allows storing configuration values but offers no secure method for handling sensitive information like passwords or tokens. Moreover, it would still require logic in the code to interpret the stored values and construct authorization headers manually.
Dynamic Endpoint: This helps when the URL of an external system changes dynamically, such as switching between environments or regions. However, it only resolves endpoint flexibility—it doesn't manage authentication. Any authentication changes would still require code modifications.
Named Credential: This is the only option that abstracts both the authentication mechanism and the endpoint. It allows Universal Containers to define either Basic Authentication or OAuth in Setup. Switching vendors or authentication types is as simple as editing or replacing the Named Credential—no code updates required.
Therefore, Named Credential (Option D) is the best solution because it offers secure, flexible, and declarative management of both authentication and endpoint configuration, which aligns perfectly with the company's requirements.
Users have reported that a Lightning Page sometimes displays outdated reference data, even though newer data exists. The page includes multiple components, some of which use caching mechanisms.
Which developer tool provides visibility into local storage and can help identify the root cause of the stale data issue?
A. Salesforce Lightning Inspector - Actions Tab
B. Salesforce Lightning Inspector - Event Log Tab
C. Salesforce Lightning Inspector - Transactions Tab
D. Salesforce Lightning Inspector - Storage Tab
Correct Answer: D
Explanation:
When a Lightning Page intermittently shows outdated or stale data, the issue often lies with client-side caching mechanisms such as localStorage, sessionStorage, or browser-based caches like IndexedDB. Lightning Web Components (LWC) and Aura Components may cache reference data to reduce server load and improve performance—but if not managed correctly, these caches can persist old data even when updates are available.
To diagnose such behavior, Salesforce offers the Lightning Inspector Chrome extension, which contains various tabs for performance analysis and debugging. Among these, the Storage Tab is the most relevant in this scenario.
The Storage Tab provides detailed visibility into:
What data is being stored locally by each Lightning Component
The structure and keys of cached data
The last modified timestamp for cache entries
How long cached values persist
Whether data is being updated correctly after changes
This information is essential for identifying cache-related problems such as:
Missing expiration policies (Time-To-Live)
Improper cache invalidation logic
Inconsistent refresh triggers when new data is available
Why other options are not appropriate:
A. Actions Tab: Focuses on server-side interactions and Apex callouts. It helps track what methods are called and the responses, but doesn’t provide any visibility into client-side caching or storage.
B. Event Log Tab: Tracks component-level events and their propagation. Useful for debugging event-driven flows, but unrelated to storage or caching behavior.
C. Transactions Tab: Offers performance insights (e.g., rendering time, component hierarchy), but does not provide details about cached data or storage state.
In contrast, the Storage Tab directly reveals how Lightning Components are managing local storage. By reviewing this tab, developers can pinpoint stale or incorrect cached entries and determine if their caching logic needs refinement—such as setting expiration times, using cache-busting keys, or re-fetching data on load.
In conclusion, when diagnosing data staleness in a Lightning Page caused by caching, the Storage Tab is the correct diagnostic tool. It provides a comprehensive look at what’s being stored in the browser, making Option D the right choice.
After deploying a Visualforce page to the Production environment, users begin to encounter ViewState errors that were not present during sandbox testing.
What is the most appropriate action the developer should take to reduce ViewState size and resolve the issue?
A. Make sure SOQL queries are within governor limits
B. Declare large or temporary properties using the transient keyword
C. Set all class properties to private access modifiers
D. Verify user profiles have access to the Visualforce page
Correct Answer: B
ViewState errors in Salesforce typically occur when the Visualforce page exceeds the 135 KB limit for ViewState, which stores page state data such as controller variables and component states across requests. While a Visualforce page may function well during development or sandbox testing (often using smaller data sets), issues can arise in production where data volumes are greater or more complex.
To resolve these issues, developers must optimize how the page handles stateful data. A key strategy is to reduce the amount of data serialized into the ViewState.
The most effective technique is to use the transient keyword in the Apex controller. When a property is declared as transient, Salesforce omits it from the ViewState. This is ideal for storing temporary data, helper variables, or non-critical information that doesn’t need to persist across postbacks.
Here, tempAccountList won’t be saved in the ViewState, freeing up space and reducing the chance of hitting the 135 KB limit.
Let’s analyze the other options:
A. Ensure queries do not exceed governor limits:
While important for Apex performance and avoiding runtime errors, governor limits (like SOQL query limits) are unrelated to ViewState errors. ViewState is about how much data is stored on the page, not how many queries are run.
C. Ensure properties are marked as private:
Property access levels (private, public, protected) influence scope, not serialization. A private variable can still be included in the ViewState if it’s referenced on the page. So, this change does not reduce ViewState size.
D. Ensure profiles have access to the Visualforce page:
This pertains to security and permissions. If a profile lacks access, the user would see an authorization error—not a ViewState issue.
In summary, the root cause of ViewState errors is the excessive serialization of stateful data. By strategically using transient, developers can reduce ViewState size, preserve performance, and ensure the Visualforce page functions reliably in production environments.
Question 6:
Which scenario best demonstrates the appropriate use of the @future annotation in Apex?
A. When performing a SOQL query that returns more than 50,000 records.
B. When updating related child records in a trigger before the DML operation.
C. When making a callout to an external web service after a DML operation.
D. When executing logic that needs to run synchronously during a Visualforce page load.
Correct Answer: C
Explanation:
The @future annotation in Apex is used to define asynchronous methods that run in a separate thread, after the current transaction is complete. This is useful when an operation is time-consuming or must be performed after a DML event, particularly in cases where performing the operation synchronously would violate Salesforce's platform limits or impact performance.
Option C correctly identifies a valid use case for @future: making a callout to an external web service after a DML operation. Salesforce enforces a strict rule that callouts cannot be made after DML operations within the same synchronous transaction. By using a @future(callout=true) method, developers can defer the web service call to run asynchronously after the DML completes. This ensures compliance with platform rules while allowing integration with external systems.
Now, let’s evaluate the incorrect options:
Option A: Performing a SOQL query that returns more than 50,000 records is not something that can be resolved using @future. The 50,000 record limit is a hard governor limit, and @future methods do not bypass this limit. To handle large data volumes, developers should consider using Batch Apex or SOQL for loops with appropriate filtering.
Option B: Updating related child records before DML in a trigger is not a valid use case for @future either. In fact, @future methods cannot be called from other asynchronous methods or from before triggers. If you need to manipulate related data in a trigger context, you should do it within the appropriate part of the execution order (e.g., after triggers), or consider alternatives like Queueable Apex if needed.
Option D: Executing logic synchronously during a Visualforce page load does not call for an asynchronous operation like @future. In fact, the user expects immediate results on the UI, and asynchronous behavior would delay visibility or interaction. Asynchronous methods are unsuitable for direct user feedback.
In summary, the @future annotation is best used when deferring processing, especially in situations involving post-DML callouts. This makes Option C the correct answer.
Question 7:
A developer is designing an Apex class to handle complex business logic for a custom object. The logic should only run after the record has been committed to the database.
The class must also ensure that the logic runs asynchronously and can handle large data volumes efficiently.Which approach should the developer use?
A. Use a before insert trigger with synchronous logic inside the trigger handler.
B. Use a Queueable class called from an after insert trigger.
C. Use a @future method from a before update trigger.
D. Call a Batchable class from a Visualforce controller.
Correct Answer: B
In this scenario, the business logic must run after the record is committed to the database and needs to execute asynchronously, making scalability and efficient handling of large data volumes essential. These requirements make the Queueable interface the best choice.
Let’s analyze the correct answer first:
B. Queueable class from an after insert trigger – This is the ideal solution. Triggers execute before the database transaction is fully committed, but after triggers are used for logic that relies on a record’s final state (like ID generation). Queueable classes allow for asynchronous execution, improved error handling over @future, and the ability to chain jobs, which is valuable in complex business flows. It’s also more efficient and flexible compared to other async options.
A. before insert trigger with synchronous logic – This fails on two fronts: it is synchronous, and it executes before the record is saved. Any logic relying on record IDs or post-commit conditions wouldn’t work properly here.
C. @future method in a before update trigger – This has multiple issues. First, @future methods cannot be reliably used in before triggers since changes may not yet be committed. Additionally, @future methods are limited: they don't support complex objects as parameters, don't allow chaining, and have higher limits constraints.
D. Call a Batchable class from Visualforce – While Batch Apex is good for large datasets, this approach doesn’t fit the scenario. Visualforce controllers are user-driven and shouldn’t be relied upon for automation of business logic. Moreover, initiating batch processing from a UI event is not a best practice for back-end logic.
Therefore, the best way to asynchronously handle logic after a record is saved and to scale effectively is using a Queueable class triggered in an after insert context.
Question 8:
A developer needs to override the default behavior of the standard Account object’s view page. The goal is to redirect users to a custom Visualforce page when they view an Account record, but only for a specific user profile.
How should the developer implement this requirement?
A. Override the standard View action with a Visualforce page and add profile-specific logic in the controller.
B. Modify the page layout for the Account object to include the Visualforce page.
C. Use a trigger to redirect the user to the Visualforce page based on profile.
D. Use a workflow rule to launch a flow that redirects to the Visualforce page.
Correct Answer: A
The requirement is to override the standard View behavior of the Account object and conditionally redirect users to a custom Visualforce page based on user profile. This is a classic use case for customizing standard actions through Visualforce page overrides.
A. Override the View action with Visualforce + profile logic – This is the correct and best approach. Salesforce allows standard buttons like "View," "Edit," or "New" to be overridden with Visualforce pages. By overriding the View action, the developer can control what page is shown when a user opens an Account record. Inside the Visualforce controller (either Apex or standard controller extensions), the developer can retrieve the current user's profile using UserInfo.getProfileId() and conditionally redirect them to a custom layout or message based on their role. This gives maximum control and aligns with Salesforce best practices.
B. Modify page layout – Page layouts only change the fields or related lists visible; they cannot redirect users or override standard navigation behavior. This won't meet the requirement of conditional redirection.
C. Use a trigger to redirect – Apex triggers are for data-level operations (insert, update, delete) and do not interact with UI. Triggers cannot redirect users or change page navigation behavior.
D. Workflow + Flow redirection – Workflow rules and Flows are good for automation but are not designed for UI redirection. They execute in the background and do not support controlling the visual flow of user navigation.
In summary, to override default behavior conditionally based on user profile, the correct and scalable solution is to override the View button with a Visualforce page, and use logic in the controller to evaluate the user’s profile and route accordingly.
A developer is implementing a future method in Apex to handle callouts to an external web service. What must the developer do to ensure the method executes correctly?
A. Annotate the method with @future and ensure it returns a String.
B. Use @future(callout=true) and ensure the method is static and void.
C. Use @future and declare the method as public to allow remote invocation.
D. Implement the Queueable interface instead of using a future method.
Correct Answer: B
Explanation:
The Salesforce Certified Platform Developer II exam tests a candidate’s ability to write scalable and efficient code, especially for asynchronous and integrated systems. When working with future methods to make HTTP callouts, there are very specific technical requirements that must be followed to ensure proper execution.
Option B is correct because in Salesforce, a method must meet three requirements when using the @future(callout=true) annotation:
It must be static.
It must return void.
It must be annotated with @future(callout=true) to enable HTTP callouts from asynchronous contexts.
This approach is used when the main Apex transaction should not wait for the response from the external service, allowing for better performance and non-blocking behavior.
Let’s review the other choices:
A is incorrect because future methods cannot return any value, including String. They must always return void.
C is incorrect because the method does not need to be public; it must be static and void. The access modifier does not influence the success of the callout.
D suggests using the Queueable interface, which is an alternative to future methods and provides more control (such as supporting non-primitive types). However, if the requirement is specifically to make a future callout, then @future(callout=true) is the correct pattern—not Queueable.
Understanding these distinctions is critical on the Platform Developer II exam, as it often tests your ability to select the right asynchronous mechanism for the task at hand. Misusing future methods or failing to include callout=true will result in runtime exceptions or failed executions, which can severely impact application functionality.
A developer needs to implement a solution that processes large volumes of data with complex business logic. The logic must be scalable and retryable in case of failure.
Which design pattern is most appropriate for this requirement?
A. Factory Pattern
B. Singleton Pattern
C. Batch Apex
D. Decorator Pattern
Correct Answer: C
Explanation:
This scenario calls for a solution that can handle large data volumes, execute complex logic, and recover from failures—all while being scalable and efficient. The correct answer is C. Batch Apex, which is a native Salesforce asynchronous processing mechanism designed specifically for handling these needs.
Batch Apex allows developers to process records in manageable chunks (batches), making it suitable for data sets that exceed governor limits such as DML operations and queries. Batch jobs are executed asynchronously in three phases:
Start – Defines the query to retrieve the data set.
Execute – Performs operations on each batch of records.
Finish – Executes logic after all batches are processed.
What makes Batch Apex ideal for this use case:
Scalability: It can handle millions of records in a resource-efficient way.
Fault tolerance: Individual batches can fail without stopping the entire job.
Retryability: Failed batches can be retried or logged for further review.
Governor limit compliance: Because each batch operates in its own transaction, limits are reset per batch.
Let’s evaluate the other options:
A. Factory Pattern is a creational design pattern used to instantiate objects without exposing creation logic. It’s useful in OOP but does not address bulk data processing.
B. Singleton Pattern ensures only one instance of a class exists, which is useful for shared resource management but irrelevant for this problem.
D. Decorator Pattern adds behavior to objects dynamically and is more relevant for UI or business logic flexibility—not batch data processing.
In summary, Batch Apex is the Salesforce-recommended solution for executing logic on large volumes of data, making it the best fit for the use case described. This topic is a frequent focus area on the exam, and understanding how and when to use Batch Apex is key for success.
Top Salesforce Certification Exams
Site Search:
SPECIAL OFFER: GET 10% OFF
Pass your Exam with ExamCollection's PREMIUM files!
SPECIAL OFFER: GET 10% OFF
Use Discount Code:
MIN10OFF
A confirmation link was sent to your e-mail.
Please check your mailbox for a message from support@examcollection.com and follow the directions.
Download Free Demo of VCE Exam Simulator
Experience Avanset VCE Exam Simulator for yourself.
Simply submit your e-mail address below to get started with our interactive software demo of your free trial.