Pass the Salesforce Developers PDII Questions and answers with CertsForce

In Lightning Web Components (LWC), components communicate up the containment hierarchy (from child to parent) by creating and dispatching Custom Events.

Unlike the older Aura framework, which used specific "Component" or "Application" event types (Options B and C), LWC relies on standard web browser event protocols. The child component (c-order) would instantiate a CustomEvent object, optionally including a data payload in the detail property (such as the orderId), and then call the this.dispatchEvent() method.

The parent component (c-selected-order) then listens for this event using an on prefix (e.g., onselection={handleSelection}) in its HTML template. While you could technically use a standard DOM event (Option D), the CustomEvent interface is the platform-standard best practice in LWC for passing custom data payloads between components. Custom events allow for clean encapsulation and follow the modern "Events Up, Properties Down" design pattern common in reactive frameworks like LWC, React, and Vue.

The failure of the assertion is caused by the with sharing keyword used in the AccountsController class and the context in which the test is running. The with sharing keyword enforces the sharing rules of the current user. In a test context, the code defaults to running as a System Administrator unless otherwise specified.

In the @TestSetup method, the developer created 10 accounts owned by a System Admin (user1) and 20 accounts owned by a Standard User (user2). When AccountsController.getAllAccounts() is called without a specific user context, it runs as the Admin and returns all 30 records. The assertion expects exactly 20 records (System.assertEquals(20, result.size())), which corresponds to the number of records owned by the Standard User.

To make the test pass, the developer must execute the method within the context of the Standard User. By querying user2 and using System.runAs(user2) (Option C), the sharing rules are enforced according to that user's perspective. Under with sharing, the Standard User will only "see" the 20 account records they own (assuming a Private OWD and no other sharing rules apply), thus satisfying the assertion. Option A is incorrect as seeAllData=true bypasses the test isolation. Option D would result in a count of 30 (or 10 if restricted), which still fails the assertion.

28

When dealing with External Users (Community/Experience Cloud users), standard sharing mechanisms like Role Hierarchies o29ften do not apply, especially for high-volume Customer Community licenses which do not use the Role Hierarchy at all.

Sharing Sets (Option B) are specifically designed to grant external users access to records associated with their Account or Contact. A Sharing Set allows an administrator to define a simple mapping: for example, "Grant access to Cases where the Case's Account matches the User's Account." This is the most efficient and scalable way to provide external partners visibility into records relevant to them without using complex Apex code.

While Apex managed sharing (Option A) could technically work, it is much more complex to maintain and is only available for "Customer Community Plus" or "Partner" licenses. Criteria-based sharing rules (Option D) are typically used for internal users or broad groups, not for granular, account-specific access for individual external partners. Sharing Sets provide a high-performance, declarative solution for controlling external record visibility.

When building global applications in Lightning Web Components (LWC), developers should never hardcode locale-specific logic. Salesforce provides a robust Internationalization (i18n) service that exposes the current user's regional settings directly to the JavaScript controller.9

The correct approach is to import the @salesforce/i18n module (Option D). This module contains several properties that are automatically populated based on the logged-in user's Salesforce profile settings. Specifically, the firstDayOfWeek property 10returns an integer (0 for Sunday, 1 for Monday, etc.) that corresponds to the cultural standard of the user's locale.

Using this built-in property is superior to other methods because:

It requires no Apex callouts or SOQL queries (unlike Option A and C).

It is automatically maintained by Salesforce; as global standards change, the platform updates the i18n values, ensuring the component remains compliant without developer intervention.

It avoids the maintenance overhead of creating custom metadata (Option B) to map every possible locale to a starting day.

By leveraging @salesforce/i18n/firstDayOfWeek, the developer ensures the calendar component is truly global and provides a native, localized experience for every user regardless of their country.

In Salesforce integration, the Upsert operation is highly powerful because it allows you to create or update records and relate them to other records using External IDs instead of Salesforce record IDs ($001...$).

When the ERP system sends an order, it may not know the 18-character Salesforce ID for the Account, but it does know the ERP_Customer_ID__c. By performing an Upsert on the Order__c object (Option A), the integration can leverage "Foreign Key" syntax in the API payload. This essentially tells Salesforce: "Create this Order and link its Account__c lookup field to the Account that has this specific ERP_Customer_ID__c."

This approach is the "Gold Standard" for integrations because:

It eliminates the need for the external system to perform a "lookup" query in Salesforce to find an ID before creating a record.

It reduces the total number of API calls, saving on governor limits.

It handles "idempotency," ensuring that if the same order is sent twice, it is updated rather than duplicated.

Options B, C, and D are less efficient. Upserting the Account (Option B) doesn't create the Order. Merging (Option C) is for deduplication. The Insert-then-Update approach (Option D) is an anti-pattern that doubles the required API calls and transaction overhead.

This scenario highlights a common conflict in multi-admin environments known as "the last delivery wins" problem. When multiple administrators work in isolated sandboxes, they are essentially working on different versions of the same metadata. If Admin A adds a field to a Page Layout and deploys it, and then Admin B—who does not have Admin A's changes in their sandbox—deploys their own version of that same Page Layout, Admin B's deployment will overwrite Admin A's changes in Production (Statement B). In the Metadata API (which Change Sets use), Page Layouts are treated as single files; you cannot "merge" them via a Change Set; you can only replace the destination file entirely.

To resolve this, the team needs a more sophisticated deployment pipeline. Statement D is the correct resolution: the company should implement a "Staging" or "Integration" sandbox. In this model, all admins deploy their Change Sets to a single unified sandbox first. This allows them to identify conflicts and "merge" their changes (manually or via source control) before a final, combined deployment is made to Production. Statement A is technically incorrect because Change Sets cannot "delete" components; they can only overwrite or add. Statement C is a myth; Page Layouts can be safely deployed, but only if the underlying fields and security settings are also included and coordinated.

Comprehensive and Deta10iled 150 to 250 words of E11xplanation:

This error occurs because Salesforce prohibits making a callout (even a mock one) in the same transaction after a DML operation has been performed. When you insert test data, it creates a "pending" transaction in the database. If you then attempt to execute a callout immediately, the platform throws the CalloutException to prevent data inconsistency issues.

To resolve this in a test context, you must separate the DML operation from the callout using the Test.startTest() and Test.stopTest() methods. When Test.startTest() is called, Salesforce provides a fresh set of governor limits and effectively creates a new transaction context for the code that follows. By inserting the records before Test.startTest() and performing the logic that triggers the callout after Test.startTest(), the developer ensures that the DML operation is "committed" to the test database context before the callout is initiated.

Option C correctly identifies this pattern. Option B is incorrect because @testSetup is used for global data creation across all test methods and does not specifically address the callout transaction split. Options A and D do not solve the problem because they either keep the DML and callout in the same context or place the DML in a context where it would still interfere with the subsequent callout request.

==========

The requirement describes a standard vertical access pattern that is best handled by the Role Hierarchy (Option C).

In Salesforce, when the Organization-Wide Default (OWD) for an object (like Case) is set to Private, the Role Hierarchy provides the following functionality by default:

Managers see subordinates' data: Users placed higher in the hierarchy automatically gain access to records owned by or shared with users below them. By placing support managers at the top of the hierarchy, they will be able to see all cases owned by the agents.

Agents see restricted data: Agents will only see the records they own or those shared with them. The requirement that they see cases owned by "someone in their role or a subordinate role" is exactly how the hierarchy facilitates vertical data flow.

While Criteria-based sharing rules (Option D) could potentially share cases with managers, it would be much harder to manage the "subordinate" logic dynamically as the team grows. Sharing Sets (Option A) are specifically for Experience Cloud (External) users and do not apply to internal support staff. Apex Managed Sharing (Option B) is a "last resort" for complex, programmatic sharing logic that cannot be achieved via declarative tools. Since the requirement aligns perfectly with the standard manager-subordinate relationship, the Role Hierarchy is the most efficient and standard solution.

Salesforce enforces a strict architectural boundary regarding database transactions and external communications. When an Apex trigger executes, it is part of a synchronous database transaction. If the platform allowed a synchronous callout (a web service call) directly from a trigger, the database transaction—including all active record locks—would have to remain open while waiting for the external system to respond. This could lead to severe performance degradation and hit the "Concurrent Request" limit.

Consequently, calling a web service from an Apex trigger (Option C) must be handled asynchronously. A developer must hand off the callout logic to an @future(callout=true) method, a Queueable class, or a Platform Event. This allows the trigger to finish its work and commit the database transaction immediately, while the callout runs in its own separate background process with its own set of governor limits.

Option A is incorrect because a standard synchronous query can retrieve up to 50,000 records. Option B is incorrect because System.scheduleBatch is a synchronous call to initiate a process, even if the process itself runs later. Option D is incorrect because record updates can be handled synchronously in an after insert trigger context.

Comprehensive and Detailed 150 to 250 words 13of Explanation:14

In a Private sharing model, access is strictly limited to owners and those grant15ed access through specific sharing mechanisms. Here, the requirement is to grant access based on a User lookup field residing on a child record (Reviewer__c) to the parent record (Defect__c).

Criteria-based sharing rules (B) are ineffective here because they can only evaluate fields on the record being shared (Defect__c) and cannot "look down" at values in related child records to determine access. "View All" (A) is too broad as it would grant the user access to every defect in the system, violating the private security model.

Apex managed sharing (D) is the correct choice. Because the relationship between the assigned reviewer and the defect is dynamic and based on a separate object, a developer can write an Apex trigger on the Reviewer__c object. When a reviewer record is created or updated, the trigger programmatically inserts a record into the Defect__Share table, granting 'Read' access to the User specified in the lookup field. This provides the precision required to ensure that only the designated reviewers can see specific defects, maintaining the integrity of the Private OWD while automating the necessary exceptions.

==========