A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question that is related to the customer community. The scenario given in this question is:
   • The community needs to function for their German- and Spanish-speaking customers.
   • That means, the same community site should show content in a specific language.
The ask is:
   • How should the developer use it to ensure the site is multilingual.
If your Salesforce org has multiple languages enabled, manage translations so that your global users can use Salesforce in their language. One of the ways is to use Custom Labels.
Custom labels enable developers to create multilingual applications by automatically presenting information (for example, help text or error messages) in a user’s native language. Custom labels are custom text values that can be accessed from Apex classes, Visualforce pages, Lightning Pages, or Lightning components. The values can be translated into any language Salesforce supports.
With this explanation, the correct answer is “Use Custom Labels to ensure custom messages are translated properly”.
References:
https://help.salesforce.com/s/articleView?id=sf.cl_about.htm&type=5
https://help.salesforce.com/s/articleView?id=sf.workbench_overview.htm&type=5

A newly added scenario and an explanation will be added in a couple of weeks.

This question is related to the concept of Transaction Control in Salesforce. Let’s learn about savepoints and considerations.
Sometimes during the processing of records, your business rules require that partial work (already executed DML statements) be “rolled back” so that the processing can continue in another direction. Apex gives you the ability to generate a savepoint, that is, a point in the request that specifies the state of the database at that time. Any DML statement that occurs after the savepoint can be discarded, and the database can be restored to the same condition it was in at the time you generated the savepoint.
Screenshot – SavePoint Example
In this example, if any error occurs while inserting the Contact “cont” then the entire transaction will be rolled back to savepoint sp1 (as specified in the catch section by Database.rollback method).

Screenshot – Considerations using savepoint

With this explanation and the above considerations, the correct answer is “Static variables are not reverted during a rollback”.
Reference:
https://developer.salesforce.com/docs/atlas.en-us.234.0.apexcode.meta/apexcode/langCon_apex_transaction_control.htm
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This is a scenario-based question that is related to performing DML operations and REST callout.
The scenario given in this question is:
• There is a code to update a Request and Request Lines and make a callout to their external ERP system’s REST endpoint with the updated records.
• The CalloutUtill.makeRestCallout falls with a ‘You have uncommitted work pending. Please commit or rollback before calling out’ error.
Please Note:
Callouts are not allowed when there is an uncommitted transaction pending. The resolution of this problem is to make the callout in a separate context.
We either need to commit the transaction, make the callout prior to any database changes or move your callout to an @future method.
With this explanation, the correct answer is:
Option “Change the CalloutUtil.makeRestCallout to an @future method” is correct.
Reference:
https://help.salesforce.com/s/articleView?id=000328873&type=1

This is a scenario-based question related to the authentication while Integrating with external systems in Salesforce. The scenario given in this question is:
    • There is a REST endpoint that supports OAuth 2.0
    • Each Salesforce user must be individually authenticated with the system
Let’s understand a few concepts.
OAuth 2.0
OAuth 2.0 is the industry-standard protocol (NOT specific to Salesforce) for providing authorization to web applications.
Named Credentials
A named credential specifies the URL of a callout endpoint and its required authentication parameters in one definition. To simplify the setup of authenticated callouts, specify a named credential as the callout endpoint.
A named credential authentication protocol supports basic password authentication, OAuth 2.0, JWT, JWT Token Exchange, and AWS Signature Version 4. You can set up each named credential to use an org-wide named principal or per-user authentication. A named principal applies the same credential or authentication configuration for the entire org, while per-user authentication provides access control at the individual user level.
With this explanation, the correct answer is:
Option “Named Credential with an OAuth Authentication Provider” is correct.
For more reference & Setup
https://help.salesforce.com/s/articleView?id=sf.named_credentials_about.htm&type=5

This question is related to the usage of Static Resource in Visualforce and Aura Components.
Static resources allow you to upload content that you can reference in a Visualforce page, including archives (such as .zip and .jar files), images, style sheets, JavaScript, and other files. Static resources can be used only within your Salesforce org, so you can’t host content here for other apps or websites.
As per Salesforce documentation, the correct answers of this question are:
Option “Relative paths can be used in files in static resource archives to refer to other content within the archive” is CORRECT
Option “Static resource files can be referenced by using the $Resource global variable instead of hardcoded” is CORRECT
Option “Static resource files can be packaged into a collection of related files in a zip or jar archive” is CORRECT
Reference:
https://help.salesforce.com/s/articleView?id=sf.pages_static_resources.htm&type=5

This is a scenario-based question that is related to using Asynchronous Apex in Salesforce.
Among the four options given, the ask is:
• “which use case can only be performed by using asynchronous Apex”?
Asynchronous Apex:
An asynchronous process is a process or function that executes a task “in the background“ without the user having to wait for the task to finish.
Asynchronous Apex comes in a number of different flavors. We’ll get into more detail for each one shortly, but here’s a high-level overview.

The following three reasons are usually behind choosing asynchronous programming.
• Processing a very large number of records: This reason is unique to the multi-tenanted world of the Lightning Platform where limits rule. The limits associated with asynchronous processes are higher than those with synchronous processes. Therefore, if you need to process thousands or even millions of records, asynchronous processing is your best bet.
• Making callouts to external web services: Callouts can take a long time to process, but in the Lightning Platform, triggers can’t make callouts directly.
• Creating a better and faster user experience: by offloading some processing to asynchronous calls. Why do everything at once? If it can wait, let it.
With this explanation, the correct answer is:
Option “Calling a web service from an Apex trigger” is correct because we cannot call external web services synchronously from triggers, because calling a web service synchronously from triggers will hold up the database transaction until the callout is completed. In this scenario, we can invoke callouts from triggers by encapsulating the callouts in @future methods. (Asynchronous Apex)
Reference:
https://help.salesforce.com/s/articleView?id=000330691&type=1

A newly added scenario and an explanation will be added in a couple of weeks.

This question is related to implementing AJAX behavior to perform partial page updates. Let’s understand a few concepts of Visualforce Page.
Implementing Partial Page Updates with Command Links and Buttons
One of the most widely used Ajax behaviors is a partial page update, in which only a specific portion of a page is updated following some user action, rather than a reload of the entire page.
The simplest way to implement a partial page update is to use the reRender attribute on an  or  tag to identify a component that should be refreshed. When a user clicks the button or link, only the identified component and all of its child components are refreshed.
Screenshot – VF Page to perform partial page updates

Screenshot – Invoking the above VF Page for Account “AB Textile”

Implementing Partial Page Updates using
Using command links and buttons to implement a partial page update is relatively simple, but suppose you want to have the same page update occur just by hovering the mouse over a contact‘s name?
To do this with the contact list example, remove the tag from the data table and wrap the contact name in an tag instead. Within this output panel, add an element as a sibling of the contact‘s name.
Therefore, in such scenarios we can use for sample code please refer:
ttps://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_quick_start_ajax_partial_page_update_any_component.htm
With this explanation, the correct answers are:
Option A is CORRECT
Option C is CORRECT
Option E is CORRECT.
References:
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_quick_start_ajax_partial_page_updates.htm
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_quick_start_ajax_partial_page_update_any_component.htm

This question is a scenario-based question and is related to the concept of Trigger Order of Execution in Salesforce.
Let’s understand the scenario given in the question:
• Apex trigger on Account that creates an Account Plan record when in Account is marked as a customer.
o That means, this Apex Trigger is written on after update event. When the Account Type is updated to “Customer”, the apex trigger logic fires and creates a record of the Account Plan object.
• Recently a workflow rule was added so that whenever an Account is marked as a customer, a ‘Customer Since’ date field is updated with today‘s date.
o That means a workflow rule is created which fires when Account Type field value is updated to “Customer” and the field update action updates the date field “Customer Since” on Account with today’s date.
The issue is given in the question:
• After the addition of the workflow rule, two Account Plan records are created whenever the Account is marked as a “Customer”.
Let’s discuss debugging:
• As we know, the logic to create a record of the Account Plan is written in the Apex Trigger which executes and creates a single record of the Account Plan. If two Account Plan records are created, that means this trigger logic is getting fired two times. BUT WHY?
• To understand this, let’s understand about Trigger Order of execution in Salesforce.
Order of Execution in Salesforce
A set of rules that describe the path a record takes through all automation and the events that happen from SAVE to COMMIT. Salesforce performs the following events in the below order.

If you see Point-13, it says that if the field was updated with workflow field update, the before and after update triggers are fired one more time (and only one more time). With this point, it‘s clear that the workflow rule added in this scenario is calling the after-update trigger again, and therefore, two Account Plan records are created.
Handle Recursion in Trigger:
To avoid the recursion of a trigger, make sure your trigger is getting executed only one time. You can use the Static Boolean variable in the apex class and check the variable in Apex Trigger IF it is true then execute your logic and make it false so that trigger cannot execute Again.
That means the Apex Trigger logic in this scenario does not use a static variable to ensure it only fires once. With this explanation, the correct answer is:
Option “The Apex Trigger responsible for the record creation does not use a static variable to ensure it only fires once” is correct.
Let’s see the below screenshot for more understanding. The code given in the below screenshot uses a static Boolean variable to avoid Recursion.
Screenshot – Apex Class having Boolean Variable

Screenshot – Apex Trigger Code using Boolean variable so that Trigger should fire once

References:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_triggers_order_of_execution.htm
https://help.salesforce.com/s/articleView?id=000332407&type=1
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question related to Lightning Component. The scenario given in this question is:
• Lightning Component should display the total number of Opportunities in the org.
• The Lightning Component uses an Apex Controller to get the data it needs.
To discover the number of rows that a query returns, use the aggregate function COUNT () in a SELECT statement of a SOQL query.
Let’s do some hands-on
Screenshot – Apex Controller & Method to return Opportunity Count

Screenshot – Aura Component (.cmp file)

Screenshot – Aura Component (.js file)

Screenshot – Adding Aura Component to App Page

With this explanation, the correct answer is “COUNT() SOQL aggregate query on the Opportunity object.”
Reference:
https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_select_count.htm

This is a scenario-based question that is related to making long-running callouts in Apex.
Sometimes we may come across certain business scenarios where we need webservice callouts that will take longer to respond. This is because the other end needs to do a significant amount of work prior to responding back. if the other end process a huge number of transactions during peak loads, the response will be even slower.
To resolve the above Salesforce limitation, we can use Continuation Class which makes asynchronous callout using REST and SOAP services. Using this class, we can make a long-running request from a Visualforce page to external systems, and its response is returned through a callback method.
Screenshot – Execution Flow of Long-Running Callout

Now, coming back to the question, it says:
• A Visualforce page needs to make a callout to get billing information and tax information from two different REST endpoints.
• Each endpoint might take up to two minutes to process. (Long Running Callout)
With this explanation, the correct answer is:
Option “A Continuation for both the billing callout and the tax callout” is correct because both the endpoint might take up to 2 minutes to process which is considered as Long-Running Callout.
Reference:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_continuation_overview.htm

This question is related to the concept of “JavaScript Remoting” & “Remote Objects” in Salesforce. Let’s look at Salesforce Documentation to check the differences between “JavaScript Remoting” & “Remote Objects”.

With this above screenshot from Salesforce Documentation, the correct answer is “Supports complex server-side application logic”.
References:
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_js_remoting_compare_remote_objects.htm
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_js_remoting_example.htm
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This question is related to the performance of the visual force page in Salesforce. The scenario given in this question is:
  • A developer created and tested a Visualforce page in their developer sandbox, but now receives reports that user encounter ViewState errors when using it in Production.
Visualforce is designed to provide developers with the ability to match the functionality, behavior, and performance of standard Salesforce pages.
There are different Visualforce performance issues and one of them is View State Size.
   • The view state size of your Visualforce pages must be under 170KB. By reducing your view state size, your pages can load quicker and stall less often.
   • You can monitor view state performance through the View State tab in the development mode footer and take the following actions:
        o Use the transient keyword in your Apex controllers for variables that aren’t essential for maintaining state and aren’t necessary during page refreshes.
        o If you notice that a large percentage of your view state comes from objects used in controllers or controller extensions, consider refining your SOQL calls to return only data that‘s relevant to the Visualforce page.
        o If your view state is affected by a large component tree, try reducing the number of components your page depends on.
With this explanation, the correct answer is “Ensure variables are marked as Transient”
Reference:
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_best_practices_performance.htm

This is a scenario-based question that is related to calling Apex Method from Lightning Web Components. The scenario given in this question is:
• There is an Apex Controller “LeadController” and a method “getFetchLeadList()” which returns a List of Lead-based on searchTerm.
• There is a Lightning Web Component having a JavaScript function that imperatively calls “getFetchLeadList()” method when certain criteria are met.
The ask is: In the given apex code, what are three changes the developer should implement to ensure LWC can display data efferently while preserving security.
Let’s check the given options and find the correct answers.
Option “Implement the with sharing keyword in the class declaration” is correct because as per apex best practice, Apex without an explicit sharing declaration is insecure by default. We strongly recommend that you always specify a sharing declaration for a class. Use the with sharing keyword when declaring a class to enforce sharing rules of the current user. Explicitly setting this keyword ensures that Apex code runs in the current user context.
Option “Annotate the Apex method with @AuraEnabled(Cacheable=true)” is correct because:
• We need to use @AuraEnabled on Apex class static methods to make them accessible as remote controller actions in your Lightning components.
• To improve runtime performance, set @AuraEnabled(cacheable=true) to cache the method results on the client. To set cacheable=true, a method must only get data. It can’t mutate data.
Option “Use the WITH SECURITY_ENFORCED clause within the SOQL query” is correct because we should use the WITH SECURITY_ENFORCED clause to enable field- and object-level security permissions checking for SOQL SELECT queries in Apex code, including subqueries and cross-object relationships.
Screenshot – Updated Code is given in Question

References:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_keywords_sharing.htm
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/controllers_server_apex_auraenabled_annotation.htm
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_with_security_enforced.htm
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This question is related to Apex Unit Test in Salesforce. The Apex testing framework enables you to write and execute tests for your Apex classes and triggers on the Lightning Platform. Apex unit tests ensure high quality for your Apex code and let you meet the requirements for deploying Apex.
Test methods must be defined in test classes, which are classes annotated with isTest. This sample class shows a definition of a test class with one test method.
Screenshot – Syntax of Test Class

Now, coming back to the question. The scenario given in this question is:
• There is a Batch Apex Class that works fine in Sandbox.
• There is an Apex Test class written for the Batch Apex but the developer cannot get code coverage on the Batch Apex class.

Please Note: The ask in this question is to write Apex Test for Batch Class which is Asynchronous in nature. A unit test forms a single transaction, and asynchronous code enqueued within that transaction cannot be executed until the transaction commits successfully.
For this reason, Salesforce has provided a framework to force asynchronous code to execute synchronously for testing: We enclose our test code between Test.startTest() and Test.stopTest() methods.
The system collects all asynchronous calls made after startTest(). When stopTest() is executed, these collected asynchronous processes are then run synchronously and complete before control returns to our code.
But as we see, the sample Apex Test code given in this question does not used Test.startTest() and Test.stopTest() methods.
Screenshot – Updated Apex Test Class
With this explanation, the correct answer is “The executeBatch must fall within test.startTest() and test.stopTest()”
Reference:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_testing_tools_start_stop_test.htm

This is a scenario-based question related to the concept of Apex Test Class in Salesforce. The scenario given in this question is:
• Visualforce page that automatically assigns ownership of an Account to a queue upon save.
• The page appears to correctly assign ownership, but an assertion validating the correct ownership fails.
o This means the Apex Test class written is getting failed and the reason is the expected and the actual value for owner is different.
Let’s take a simple example & reproduce the same scenario with Case Object.
• There is an Apex Class & method to update the specific Case record to Queue.
• There is an Apex Test Class to cover this scenario.
• At LINE-20 of Apex Test Class “CaseExTest”, we expect the Case Owner to be updated to Queue.
Screenshot – Apex Class having method “updateCaseOwner”

Screenshot – Apex Test Class

Screenshot – Test Class failed with below Error

Please Note: If you see LINE-20 of the above Apex Test Class, it does not retrieve the updated case record. Therefore, the resolution of this issue is we need to fetch the latest version of Apex Test Class and assert it.
Screenshot – Updated Test Class

With this explanation, the correct answer is:
Option “The test class does not retrieve the updated value from the database” is correct.

This is a scenario-based question related to the concept of tracking fields on records. The scenario given in this question is:
   • There are two objects. Standard object “Opportunity” and custom object “Sales_Help_Request__c”.
   • Custom object “Sales_Help_Request__c” has lookup relationship to Standard object “Opportunity”
   • There is a field “Number_of_Hours__c” on Custom object “Sales_Help_Request__c” to represents the amount of time spent on the Sales_Help_Request__c.
   • There is a field “Total_Hours__c” on Standard object “Opportunity” that should be the sum of all of the “Number_of_Hours__c” values for the Sales_Help_Request__c records related to that Opportunity.
The requirement is:
   • How to populate the “Total_Hours__c” field on Opportunity that should be the sum of all of the “Number_of_Hours__c” values for the Sales_Help_Request__c records related to that Opportunity.
This requirement is very simple to implement by using “Roll-up Summary Field” if the relationship between two objects is a “Master-Detail” relationship.
A roll-up summary field calculates values from related records, such as those in a related list. You can create a roll-up summary field to display a value in a master record based on the values of fields in a detail record.
But, here we can not use roll-up summary field because the relationship between Opportunity and Sales_Help_Request__c is Lookup.
There are 4 ways one can work around this:
   • An AppExchange App
   • A Flow
   • Apex Triggers
   • Reporting
With this explanation, the correct answer is “A trigger on Sales_Help_Request__c” because when the Number_of_Hours__c field of any Sales_Help_Request__c record is changed, then for the corresponding Opportunity record, the logic needs to add all the Number_of_Hours__c field values and update the “Total_Hours__c” field on the Opportunity record.

This question is related to an issue while creating an Application Event in Aura Component. The issue given in this question while creating the Application Event is:
• Application event is triggering an infinite loop.
Let’s understand the basics about Application Event
Application events follow a traditional publish-subscribe model. An application event is fired from an instance of a component. All components that provide a handler for the event are notified.
As per salesforce documentation, there are some anti-patterns that we should avoid when using events.

With this explanation, the correct answer is “The event is fired from a custom renderer” because it can cause an infinite rendering loop.
References:
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/events_anti_patterns.htm
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/events_application.htm

This is a scenario-based question related to the concept of Transaction Control in Salesforce. The scenario given in this question is:
• There is an Apex Class having three savepoints SP1, SP2 and SP3
• There three savepoints are created in sequence/order.
• For a given condition, there is a logic to roll back to SP1. The code then calls roll back to SP3 to continue with the final execution.
• The problem is: When the code rolls back to SP3, the runtime error occurs.
Let’s understand a few concepts about Transaction Control in Apex
While implementing using Apex, there are certain business rules which require partial work (already executed DML statements) be “rolled back” so that the processing can continue in another direction. Apex gives you the ability to generate a savepoint, that is, a point in the request that specifies the state of the database at that time. Any DML statement that occurs after the savepoint can be discarded, and the database can be restored to the same condition it was in at the time you generated the savepoint.
As per the Salesforce Documentation, there are the following limits while using savepoint variables and rolling back to the database.

Now, coming back to the question, the same scenario given in the question is yellow highlighted.
• For a given condition, there is a logic to roll back to SP1. The code then calls roll back to SP3 to continue with the final execution.
With this explanation, the correct answer is:
Option “SP3 became invalid when SP1 was rolled back” is correct because savepoints SP1, SP2, and SP3 are in sequence and when the code rollbacks to SP1, the SP3 becomes invalid.
Reference:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/langCon_apex_transaction_control.htm

This question is related to the concept of “Field History Tracking” in Salesforce. In Salesforce, we can select certain fields to track and display the field history in the History related list of an object.
Salesforce stores an object’s tracked field history in an associated object called StandardObjectNameHistory or CustomObjectName__History. For example, OpportunityHistory represents the history of changes to the values of an Opportunity record’s fields. Similarly, MyCustomObject__History tracks field history for the MyCustomObject__c custom object.
OpportunityHistory
Represents the stage history of an Opportunity. This object represents the history of a change to the Amount, Probability, Stage, or Close Date fields of an Opportunity. The OpportunityFieldHistory object represents the history of a change to any of the fields of an Opportunity.
As per Salesforce Documentation, to obtain information about how a particular opportunity is progressing, query the OpportunityHistory records associated with a given Opportunity. Please note that if an opportunity‘s Amount, Probability, Stage, or Close Date fields have not changed, nothing will be returned in the OpportunityHistory objects.
For Example, Let’s say:
• We created an Opportunity named “AC INSTALLATION”. At this time, we kept Amount as blank and Stage = “Prospecting”
• Then we updated the Stage from “Prospecting” to “Qualification.
• Then we updated the Amount from blank to “1000000”.
Now, let’s Query to OpportunityHistory Object.
Screenshot – Query to OpportunityHistory

With this explanation, the correct answer is:
[Select Amount, CloseDate, StageName, Probability FROM OpportunityHistory WHERE OpportunityId = :oppId] ;
Reference:
https://developer.salesforce.com/docs/atlas.en-us.api.meta/api/sforce_api_objects_opportunityhistory.htm

This is a scenario-based question. The scenario given in this question is:
• A company needs to automatically delete sensitive information after seven years.
• This could delete almost a million records every day.
Conclusion
• The records deleted will be in high volume (millions of records)
• This scenario does not require any synchronous behavior as the records should be deleted after 7 years.
Solution Approach
• We need to use the asynchronous apex feature of Salesforce as the data deletion needs to happen in the backend without impacting any other logic.
• We need to specifically use “Batch Apex” (Asynchronous Apex) because the requirement is of data cleaning which may be millions of records.
Let’s learn more about a high-level overview of Asynchronous Apex features with use cases.

With this explanation, the correct answer is “Schedule a batch Apex process to run every day that queries and deletes records older than seven years”
Trailhead Module:
https://trailhead.salesforce.com/content/learn/modules/asynchronous_apex/async_apex_introduction
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This is a scenario-based question and is related to the authentication mechanism used in Salesforce. The scenario given in this question is:
• Universal Containers wants to use an external Web Service provided by a third-party vendor to validate that shipping and building addresses are correct.
• The current vendor uses basic password authentication.
• Universal Containers might switch to a different vendor who uses OAuth.
That means Universal Containers may need to switch to a different vendor who uses OAuth so, which feature we can use in Salesforce supports different authentication like password authentication, OAuth 2.0, JWT etc.
As per Salesforce documentation, we can use Named Credential.
• A named credential authentication protocol supports basic password authentication, OAuth 2.0, JWT, JWT Token Exchange, and AWS Signature Version 4.
• You can set up each named credential to use an org-wide named principal or per-user authentication. A named principal applies the same credential or authentication configuration for the entire org, while per-user authentication provides access control at the individual user level.
Screenshot – Named Credential Setup

With this explanation, the correct answer is “Named Credential”
Reference:
https://help.salesforce.com/s/articleView?id=sf.named_credentials_about.htm&type=5
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This is a scenario-based question that is related to implementing the partial page updates using .
The scenario given in this question is:
• In Visualforce Page, there is an Industry select list.
• When a user changes the value in the industry select list, the table of Accounts should be automatically updated based on the selected industry
To understand this, let‘s write some code. We have created an Apex Class and a Visualforce Page.
Screenshot – Apex Class (controller)

Screenshot – Visualforce Page

Screenshot – Invoking the Visualforce Page

From the above example,
• We have used to implement partial page update behavior.
• With we have used “onchange” event because the requirement is to refresh the Account Detail when Industry value changes.
• The “reRender” attribute specifies which part of the page should refresh.
• The is used within
With this explanation, the correct answer is:
Option “Add an within the ” is correct
References:
https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_quick_start_ajax_partial_page_update_any_component.htm
https://developer.salesforce.com/docs/atlas.en-us.234.0.pages.meta/pages/pages_compref_selectList.htm

This question is related to the concept of Relationship Queries in Salesforce. Let’s learn some basics about it.
Relationship Queries
Client applications need to be able to query for more than a single type of object at a time. SOQL provides syntax to support these types of queries, called relationship queries, against standard objects and custom objects.
There are two types of relationship queries:
• Parent-to-child relationships
o This simply means we query to parent objects and also get child records.
• Child-to-parent relationships
o This means we query to child and get parent fields.
Understanding Relationship Names
Parent-to-child and child-to-parent relationships exist between many types of objects. For example, an Account is a parent of Contact.

For child-to-parent relationships, the contact child object has a child-to-parent relationship to the Account object, so the value of the relationshipname in Contact is Account.
For parent-to-child relationships, the parent object has a name for the child relationship that is unique to the parent, the plural of the child object name. For example, Account has child relationships Contacts and has a relationshipName as Contacts.
Syntax – child to parent Query
Specify these relationships directly in the SELECT, FROM, or WHERE clauses using the dot (.) operator.
SELECT Id, Name, Account.Name FROM Contact
Syntax – parent to child
Specify these relationships using a subquery (enclosed in parentheses), where the initial member of the FROM clause in the subquery is related to the initial member of the outer query FROM clause.
SELECT Id, (SELECT LastName FROM Contacts) FROM Account
Now, coming back to the options given.
The below option is NOT CORRECT because this is a child-to-parent query having a child as Contact and Account as a parent and the relationshipName in Contact is Account but it uses Account__r.
SELECT Id, Name, Account__r.Name FROM Contact WHERE Account__r. Industry = ‘Media’
The below option is NOT CORRECT because this is a parent-to-child query having a child as a Contact and an Account as a parent. Account has child relationships Contacts and has a relationshipName as Contacts. But it uses Contacts__r
SELECT Name, (SELECT LastName FROM Contacts__r) FROM Account.
The below option is CORRECT as it uses correct relationshipName and syntax.
SELECT Name, (SELECT LastName FROM Contacts) FROM Account.
The below option is CORRECT as it uses correct relationshipName and syntax.
SELECT Id, Name, Account.Name FROM Contact WHERE Account.Industry = ‘Media’
References:
https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_relationships_understanding.htm#sforce_api_calls_soql_relationships_understanding
https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_relationships_query_using.htm#sforce_api_calls_soql_relationships_query_using

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question related to the topic “User Interface Development Considerations” in Salesforce.
The scenario given in this question is:
    • There is a need to develop a page-centric application that allows the user to interact with multiple objects related to a Contact.
    • The application needs to implement a third-party JavaScript framework such as Angular and must be made available in both Classic and Lightning Experience.
The requirement is to choose the best / recommended solution to develop the application.
As per Salesforce Documentation, Visualforce is conceptually similar to other page-centric technologies like PHP, ASP, JSP, and Ruby on Rails. Salesforce’s rich metadata infrastructure makes Visualforce a productive solution.
Visualforce pages are just HTML pages with extra tags resolved by the server. As a result, you can use an empty Visualforce page as a container for a JavaScript application. In this scenario, you don’t use Visualforce tags to build your user interface. Instead, you load your JavaScript application on an empty page. Then the user interface is generated on the client-side by the JavaScript application. These applications are generally referred to as single-page applications, or SPAs, and are often built using third-party frameworks like AngularJS or React.
With this explanation, the correct answer is:
Option “Visualforce” is correct because it can be used to develop page-centric applications & can be used as a container for your third-party framework, such as AngularJS or React, and your application.
Reference:
https://trailhead.salesforce.com/en/content/learn/modules/lex_dev_overview/lex_dev_overview_future

This question is related to Testing HTTP Callouts by Implementing the HttpCalloutMock interface. The scenario given in the question is:
• The sample Apex Test code is given to create a fake response.
The ask in this question is:
• Which method can be called to return this fake response in the test methods?
As per the Salesforce Document, once we have specified the values of the fake response, instruct the Apex runtime to send this fake response by calling Test.setMock in your test method. For the first argument, pass HttpCalloutMock.class, and for the second argument, pass a new instance of your interface implementation of HttpCalloutMock, as follows:

With this explanation, the correct answer is “Test.setMock”
Reference:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_restful_http_testing_httpcalloutmock.htm
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

A newly added scenario and an explanation will be added in a couple of weeks.

This question is related to Apex Test Class in Sandbox and Production. The scenario given in this question is:
   • A developer sees test failures in the sandbox but not in production.
   • No code or metadata changes have been actively made to either environment since the sandbox was created.
The requirement is:
   • Which consideration should be checked to resolve the issue?
If we consider Point-2, it says No code or metadata changes have been actively made. Therefore, the below options are incorrect.
Option “Ensure Workflow Rules are inactive” is not correct because Apex Test should cover the scenarios which is mostly related to Apex Code and also it is said that No code or metadata changes have been actively made.
Option “Ensure Process Builder processes are inactive” is not correct because Apex Test should cover the scenarios which is mostly related to Apex Code and also it is said that No code or metadata changes have been actively made.
Option “Ensure the Apex Classes are on the same API version” is not correct because it does not impact.
Option “Ensure the sandbox is on the same release as production” is correct because once a new release comes, the best approach is to refresh the sandbox and test existing customizations against release features. So, it might be the reason that the Sandbox is refreshed and has a new release.

This question is related to the concept of Selective Queries in Salesforce. First of all, let’s learn about few concepts.
Index Fields in Salesforce
In the modern cloud application with a large data set like Salesforce, indexing is very important to allow an application to search and return results to users at a minimum time and cost.
There are 2 types of indexes in Salesforce:
   • Standard Index
   • Custom Index
Salesforce maintains indexes on the following fields for most objects:
   • Salesforce record ID
   • RecordTypeId
   • Division
   • CreatedDate
   • Systemmodstamp (LastModifiedDate)
   • Name
   • Email (for contacts and leads)
   • Lookups and master-detail relationship
Salesforce administrator can define a custom index field by making by making the field as “External ID” or unique field for the following field type:
   • Number
   • Auto-number
   • Text
   • Email
Selective SOQL Queries:
SOQL queries must be selective, particularly for queries inside triggers for the best performance. To avoid long execution times, non-selective SOQL queries may be terminated by the system.
A query is selective when one of the query filters is on an indexed field and the query filter reduces the resulting number of rows below a system-defined threshold.
Now, coming back to the question, the scenario given is
   • Assume that there are more than 200,000 Account records.
   • These records include soft-deleted records: that is, deleted records that are still in the Recycle Bin.
   • there are two fields that are marked as External Id on the Account.
       o Customer_Number__c
       o ERP_Key__c
The ask is:
   • Which two queries are optimized for large data volumes?
With this explanation, the correct answers are:
The below Option is correct because the WHERE clause is on an indexed field (Id).
SELECT Id FROM Account WHERE Id IN :aListVariable
The below Option is correct because the field Customer_Number__c is selective.
SELECT Id FROM Account WHERE Name != ‘ ‘ AND Customer_Number__c = ‘ValueA‘
Reference:
https://help.salesforce.com/s/articleView?id=000325247&type=1

This is a scenario-based question that is related to Sending Emails to customers. The scenario given in this question is:
• There is a need to automatically send an email to the customer when an Opportunity stage changes.
• The solution must scale to allow for 10,000 emails per day.
• The criteria to send the email should be evaluated after all workflow rules have been fired.
Please Note: The important part here is “The criteria to send the email should be evaluated after all workflow rules have fired”. That means this is related to Order of Execution in Salesforce.
Order of Execution in Salesforce
A set of rules that describe the path a record takes through all automation and the events that happen from SAVE to COMMIT.
Salesforce performs the following events in the below order.

Now coming back to the question, it says that “The criteria to send the email should be evaluated after all workflow rules have fired”. If we see the Order of Execution, the Apex Trigger and workflow rule fire before Process.
With this explanation, the correct answer is
Option “Use an Email Alert with Process Builder.” is correct
Reference:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_triggers_order_of_execution.htm

This question is related to Aura Component Bundle Design Resources.
Let’s learn the basics about Design resources:
Use a design resource to control which attributes are exposed to builder tools like the Lightning App Builder, Experience Builder, or Flow Builder. A design resource lives in the same folder as your .cmp resource and describes the design-time behavior of the Aura component—information that visual tools need to display the component in a page or app.
Screenshot – Aura Component (.cmp file)

Screenshot – Aura Component (.design file)

design:attribute
To make an Aura component attribute available for admins to edit in tools such as the App Builder, add a design:attribute node for the attribute into the design resource.
and
Use these tag sets to restrict your component to one or more objects.

Now, coming back to the question it says
• To displays a specified Account Field Set
o For this, we need to use
• To restrict the component to the Account record page.
o For this, we need to use Account
With this explanation, below is the correct answer because it uses and Account

Account
</ sfdc:objects>

Reference:
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/components_config_for_app_builder_design_files.htm

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question related to the concept of Apex Trigger and Test Class. The scenario given in this question is:
• There is an Apex Trigger on Opportunity that will update a custom Last Sold Date field on the Opportunity’s Account whenever an Opportunity is closed.
• There is an Apex Test class written to cover this scenario.
The ask in this question is:
• In the Apex Test class for the trigger, the assertion to validate the Last Sold Date field fails. What might be causing the failed assertion?
Let’s recreate the Scenario.
Screenshot – Apex Trigger

Screenshot – Apex Trigger Test

Screenshot – Error while running above Test Class

As per the scenario given in the question, the assertion is getting failed with error: Expected = 2022-02-19 and Actual = null for Last Sold Field on Account.
But as per the Trigger Code, we know that when the Opportunity Stage is updated to “Closed”, the Last Sold Date field on Account should be updated to TODAY’s date but WHY its null.
Please Note: In the Apex Test Class, we are using Account acct to check the Last Sold Date after Opportunity is updated. But the correct approach is we should re-query the Account record after the Opportunity record is updated.
Screenshot – Correct Apex Test Class

With this explanation, the correct answer is “The test class has not re-queried the Account record after updating the Opportunity”
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This question is related to the concept of Selective Queries in Salesforce. First of all, let’s learn about few concepts.
Index Fields in Salesforce
In the modern cloud application with a large data set like Salesforce, indexing is very important to allow an application to search and return results to users at a minimum time and cost.
There are 2 types of indexes in Salesforce:
• Standard Index
• Custom Index
Salesforce maintains indexes on the following fields for most objects:
• Salesforce record ID
• RecordTypeId
• Division
• CreatedDate
• Systemmodstamp (LastModifiedDate)
• Name
• Email (for contacts and leads)
• Lookups and master-detail relationship
Salesforce administrator can define a custom index field by making by making the field as “External ID” or unique field for the following field type:
• Number
• Auto-number
• Text
• Email
Selective SOQL Queries:
SOQL queries must be selective, particularly for queries inside triggers for the best performance. To avoid long execution times, non-selective SOQL queries may be terminated by the system.
A query is selective when one of the query filters is on an indexed field and the query filter reduces the resulting number of rows below a system-defined threshold.
Now, coming back to the question,
• The Query given is: SELECT Id, Name FROM Contact WHERE CustomField_c = null;
• The ask is how to improve the performance to Query.
The correct answers are:
Option “Make the CustomField__c field an External ID” is correct because we can define the custom index field by making it External Id.
Option “Make the field CustomerField__c required because Salesforce field indexes do not include nulls” is correct.
References:
https://help.salesforce.com/s/articleView?id=000325247&type=1
https://developer.salesforce.com/docs/atlas.en-us.228.0.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_case_studies_indexing_with_nulls.htm
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

This is a scenario-based question related to deploying components from Sandbox to Production.
The scenario given in this question is:
   • In a company, there are different departments and each department has its own Salesforce administrator.
   • Each administrator has its own Sandbox to test the changes done.
   • There are below few issues they are noticing:
       o Fields that are recently added for one department suddenly disappear without warning.
       o Workflows that once sent emails and created tasks no longer do so.
The ask is:
What is the root cause of the above issues?
From the above scenario, we can see that each administrator has its own Sandbox and they can deploy components from Sandbox to Production. In this situation, there are more chances that the same component can be overlapped.
For example: Let’s assume.
   • Sandbox-1 having Case Page Layout having a field “Reason”
   • Sandbox-2 having Case Page Layout does not have field “Reason”
   • Now, if the Case Page Layout is deployed from Sandbox-1 to Production. Therefore, the Case Page Layout in Production will have the field “Reason”
   • But, after that if Case Page Layout does not have the field “Reason” is deployed from Sandbox-2 to Production. It will override the Case Page Layout in Production.
Therefore, as per best practice: A Sandbox should be created to use as a unified testing environment and all the production deployment should happen from the unified Sandbox.
With this explanation, the correct answer is:
Option “A sandbox should be created to use as a unified testing environment instead of deploying Change Sets directly to production” is correct.
Option “The administrators are deploying their own Change Sets over each other, thus replacing entire Page Layouts and Workflows in Production” is correct
Reference:
https://help.salesforce.com/s/articleView?id=000338970&type=1

An Apex callout enables you to tightly integrate your Apex with an external service by making a call to an external Web service or sending a HTTP request from Apex code and then receiving the response. Apex provides integration with Web services that utilize SOAP and WSDL, or HTTP services (RESTful services).
Please Note:
   • Before any Apex callout can call an external site, that site must be registered in the Remote Site Settings page, or the callout fails. Salesforce prevents calls to unauthorized network addresses.
   • If the callout specifies a named credential as the endpoint, you don’t need to configure remote site settings. A named credential specifies the URL of a callout endpoint and its required authentication parameters in one definition.
About Named Credentials
   • A named credential specifies the URL of a callout endpoint and its required authentication parameters in one definition. Salesforce manages all authentication for Apex callouts that specify a named credential as the callout endpoint so that your code doesn’t have to. You can also skip remote site settings, which are otherwise required for callouts to external sites, for the site defined in the named credential.
   • Named Credentials also include an OutboundNetworkConnection field that you can use to route callouts through a private connection. By separating the endpoint URL and authentication from the callout definition, named credentials make callouts easier to maintain.
For example, if an endpoint URL changes, you update only the named credential. All callouts that reference the named credential simply continue to work.
With this explanation, the correct answer is “Named Credentials”.
References:
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_callouts.htm
https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_callouts_named_credentials.htm

This question is related to Lightning Web Component. The scenario given in this question is:
• There is a button on the custom Lightning Web Component but it’s not working.
• There are no other details provided.
The ask in this question is:
• What should the developer use to ensure that error messages are properly displayed.
• That means, whenever an error occurred, we need to show that error to the user.
The correct answer to this question is “Add JavaScript and HTML to display an error message.” because to display an error message in Lightning Web Component, we can add logic in to the javascript file.
That means, the js file can collect the error and display it. There are several ways to achieve this. One of the ways is to use the toast component.
Let’s see an example.
Screenshot – LWC .html file

Screenshot – LWC .js file

Reference:
https://developer.salesforce.com/docs/component-library/bundle/lightning-platform-show-toast-event/documentation

A newly added scenario and an explanation will be added in a couple of weeks.

This question is related to using an external JavaScript library in Lightning Component. As per Salesforce documentation, To reference a JavaScript library, upload it as a static resource and use a tag in your .cmp or .app markup.
Therefore, there are two steps:
1. Load the external JavaScript library in the static resource.
2. Use tag to load the JavaScript library in the lighting Component as shown below:
Screenshot – Use the join operator to include multiple libraries in Lightning Component
With this explanation, the correct answer is: “Join multiple assets from a static resource” because we need to use the join operator to incorporate multiple JavaScript libraries in a Lightning component.

Reference:
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/js_libs_platform.htm

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question that is related to the SOQL query in Salesforce. The scenario given in this question is:
• Given a list of Opportunity records named opportunityList, which code snippet is best for querying all Contacts of the Opportunity’s Account
Please Note:
• In Salesforce, contact records do not have a direct relationship with Opportunities.
• Opportunities have a relationship with an Account record, and the Account has a relationship with Contacts – yet, no direct relationship.
Screenshot – Relationship between Contact, Account, and Opportunity

Let’s check the given options.
The below Option is NOT CORRECT because there is no direct relation between Contact and Opportunity. Therefore, we can not have ContactId on the Opportunity record.

The below option is NOT CORRECT because opportunityList.AccountId is invalid.

\
The below option is CORRECT because it uses the correct approach by querying parent-to-child, which are almost always one-to-many. Specify these relationships using a subquery (enclosed in parentheses), where the initial member of the FROM clause in the subquery is related to the initial member of the outer query FROM clause.
Note that for standard object subqueries, you should specify the plural name of the object as that is the name of the relationship for each object.
1. Collecting AccountId in a collection using Set
2. Querying Account with Contact using Set of AccounId
3. Adding contacts to a List named as ContactList

Reference:
https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_relationships_query_using.htm#sforce_api_calls_soql_relationships_query_using

This question is related to integrating the legacy systems with Salesforce. The ask in this question is “what should the developer use to ensure the data being integrated is matched to the right records in Salesforce”?
That means this scenario is all ensuring record matching so no duplicate records are inserted/updated.
This can be achieved by using the “External Id Field”.
The External ID field allows you to store unique record IDs from an external system, typically for integration purposes. For example, if we have a legacy system that needs to load/update data in Salesforce may reference these external records in Salesforce using unique Ids from Legacy system records.
To enable the External ID flag for a field:

• Navigate to the object‘s field list
• In Classic, go to Setup | Create | Objects | <object name> | Fields
• In Lightning Experience, go to Setup | Object Manager | <object name> | Fields & Relationships.
• Then, click Edit next to the field name to enable the External ID checkbox.

Screenshot – To make a field as External Id

With this explanation, the correct answer is “External Id field”

Reference:

https://help.salesforce.com/s/articleView?id=sf.faq_import_general_what_is_an_external.htm&type=5

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question that is related to “Salesforce & Heroku Integration”. The scenario given in this question is:
• Ursa Major Solar (UMS) needs to integrate with a Heroku service that resizes product images submitted by users.
The ask in this question is:
• What are the ways to implement the integration and protect against malicious calls to the Heroku app‘s endpoint.
As per Salesforce Documentation, there are two primary methods to call a Heroku app based on an event in Salesforce:
• Workflow outbound messages
    o A workflow outbound message declaratively makes a SOAP call.
    o While configuring outbound message, if we select “Send Session Id” the Heroku app can use that token to make REST API calls on the user’s behalf. If you don‘t send the session ID. there‘s no way to check that the request was valid or protect against malicious calls to your Heroku app’s API endpoint.
•   Apex HTTP callouts
    o An Apex HTTP callout programmatically makes a REST call to a Heroku app.
    o With Apex triggers, you can use some form of pre-shared key to authenticate requests, avoiding the potential for malicious requests. You can also have the payload include a session ID to let the Heroku app make REST API requests back to Salesforce to fetch or update data.
With this explanation, the correct answers are:
Option “Create a Workflow Rule with an Outbound Message and select Send Session ID so that the Heroku app can use it to send the resized images back to Salesforce” is correct.
Option “Create a trigger that uses an @future Apex HTTP callout passing JSON serialized data and some form of pre-shared secret key, so that the Heroku app can authenticate requests and store the resized images in Salesforce” is correct.
Trailhead Module:
https://trailhead.salesforce.com/en/content/learn/modules/salesforce_heroku_integration/callouts_workflow_with_heroku
PD2 Trail Mix:
https://trailhead.salesforce.com/en/users/strailhead/trailmixes/prepare-for-your-salesforce-platform-developer-ii-credential

A newly added scenario and an explanation will be added in a couple of weeks.

A newly added scenario and an explanation will be added in a couple of weeks.

This question is related to Component Event and specifically about how to fire an event in Aura Component. The scenario given in this question is:
• When the search is completed, a searchComplete event is fired.
• While firing the event, the results put in a results attribute of the event.
The ask is:
• What is the optimal code that should be added to fire the event when the search has been completed?
As per Salesforce documentation, a Component event to communicate data to another component. A component event can be handled by the component that fired the event or by a component in the containment hierarchy that receives the event.
To fire a component event, there are two steps:
1. Register an event
A component registers that it may fire an event by using in its markup. For example:

2. Fire an event
To get a reference to a component event in JavaScript, use cmp.getEvent(“evtName“) where evtName matches the name attribute in .
With this explanation, coming back to the options given:
Below is the correct answer because it uses getEvent() to get the reference of this component & also it uses the correct syntax to pass parameters to the event.

var evt = component.getEvent (“searchComplete“);
evt.setParams ({ results: results});
evt.fire();
Reference:
https://developer.salesforce.com/docs/atlas.en-us.lightning.meta/lightning/events_component_fire.htm

This is a scenario-based question that is related to Sharing a record using Apex.
The scenario given in this question is:
• There is a private sharing model for the Convention_Attendee__c custom object.
o Please Note: Since the sharing model is private. The Non Owner should not be able to view the Convention_Attendee__c custom object record.
• There is a field Event_Reviewer__c on the custom object having lookup to the User.
Requirement
Event Reviewer to automatically gain Read/Write access to every record they are assigned to. That means, when the record of Convention Attendee custom object is created, the associated user should also get the Read/Write access.
Criteria-Based Sharing Rules
A criteria-based sharing rule determines with whom to share records based on field values. But in the scenario given in this question, the criteria is not universal so we can not use it. Therefore we need to use Apex.
Sharing a Record Using Apex
To access sharing programmatically, you must use the share object associated with the standard or custom object for which you want to share. All custom object sharing objects are named as follows:
• Name of custom object = “MyCustomObject”
• Name of share object = “MyCustomObject__Share”
Every share object has the following properties:

Now, coming back to the question:
• Since the custom object name is Convention_Attendee__c, the share object will be created as “Convention_Attendee__share” because the Organization-Wide Default sharing setting was set to private.
• From the above table, we know that to create a record for the “Convention_Attendee__share” object, we need to assign “ParentId”, which is the Id of the record being shared. (Id of Convention_Attendee__c record in this scenario)
Now, coming back to the options given, the correct answer is:
Option “Create an After-Insert trigger on the Convention Attendee custom object, and use Apex Sharing Reasons and Apex Managed Sharing” is correct because we need to Set the ID of the record being shared which we can only have in After Trigger Context.
Option “Create a Before Insert trigger on the Convention Attendee custom object, and use Apex Sharing Reasons and Apex Managed Sharing” is not correct in Before Trigger, we do not have the Id of record being shared.
Reference & code example:
https://developer.salesforce.com/docs/atlas.en-us.204.0.apexcode.meta/apexcode/apex_bulk_sharing_creating_with_apex.htm

A newly added scenario and an explanation will be added in a couple of weeks.

A newly added scenario and an explanation will be added in a couple of weeks.

This is a scenario-based question that is related to the concept of External Id in Salesforce.
External Id in Salesforce
An External Id is a custom field that has the External ID attribute, meaning that it contains unique record identifiers from a system outside of Salesforce.
Now, let’s understand the scenario given in this question:
• The Account object in Salesforce contains a field marked as External Id. The API name of this field is Legacy_Id__c.
• There is a need to write Apex Method that relates new Contact records to existing Accounts in Salesforce. The sample code given in this question is:

The ask is:
What is the most efficient way to instantiate the parentAccount variable on line 02 to ensure the newly created contact is properly related to the Account?
Let’s understand this by an example. We created a field on Account Object called “Legacy_Id__c” and written an Apex Method to create new Contact and associate the Contact with Account.
Screenshot – Created External Id field on Account Object

Screenshot – Created Apex Class

With the above Apex Code, we can see that:
• The Account is instantiated based on the Legacy_Id__c field which is an external identifier.
With this explanation, the correct answer is:
Option “Account parentAccount = new Account (Legacy_Id_c = externalIdentifier)” is correct.

This question is related to the concept of Recursive Trigger in Salesforce. The scenario given in this question is:
• There is a trigger class to increment a counter “Edit_Count__c”, any time that the Case is changed.
• After a new Process is created, it seems Edit Count is being incremented by more than one on Case edits.
Handle Recursion in Trigger
To avoid the recursion on a trigger, make sure your trigger is getting executed only one time. You can use Static Boolean variable in apex class and check the variable in Apex Trigger IF it is true then execute your logic and make it false so that trigger cannot execute Again.
Screenshot – Apex Class having Boolean Variable

Now, we can use this Boolean variable in the Trigger before calling the apex method and then update the Boolean variable value to false.
With this explanation, let’s find the correct answers from the options given.
The below Option is CORRECT because it added the static Boolean variable to the apex class.

The below option is CORRECT because it uses the Boolean variable before calling the Apex Methods.

Reference:
https://help.salesforce.com/s/articleView?id=000332407&type=1

This is a scenario-based question related to developing Lightning Components. The scenario/requirement given in this question is:
   • The implementation should work in multiple device form factors, such as desktops, phones, and tablets.
   • The implementation must support Addressable URL Tabs and interact with the Salesforce Console APIs.
For the second point, To enable direct navigation to a Lightning component via URL, add the lightning:isUrlAddressable interface to the component. But this is not supported in Lightning Web Components. Therefore, we can implement this in two ways:
   • Either use Aura Component or
   • Use Lightning Web Component wrapped inside Aura Component so that the parent Aura Component can be used to achieve Addressable URL functionality.
With this explanation, the correct answers are:
Option “Create the application using Aura Components” is correct.
Option “Create the application using Lightning Web Components wrapped in Aura Components.” is correct
Reference:
https://developer.salesforce.com/docs/component-library/bundle/lightning:isUrlAddressable/documentation

This is a scenario-based question that is related to using Apex and Outbound Messaging for the callout to an external system.
Salesforce provides the following features to implement Integration:
   • Apex Callout
   • Outbound Messaging (OM)
It is very important that we fully understand the capabilities of these features and then decide on a suitable approach.
1. Apex Callout:
   • Enable Apex to invoke external web services. This allows you to connect to 3rd party web services such as Google, Amazon, Facebook, and any other external web service.
   • Callout requires familiarity with Apex coding
   • Transaction failure & retry logic should be explicitly coded
   • Supports both SOAP & REST API Invocation
   • Sync & Async requests handling is supported
2. Outbound Messages:
   • OM can be implemented using Point & Click tools without having to write any code in Salesforce.
   • Sends configured fields in the form of the XML SOAP message to the specified end-point.
   • The destination endpoint should be setup in a specific way for it to accept the contents of the SOAP message being sent. We won’t be able to use the existing web services of the Target system.
   • We can only send single parent record fields in the SOAP message. Additional web service transactions should be issued back to Salesforce (from custom solution) using the session id sent in the SOAP message to get additional (related) records.
Now, coming back to the question, it says in which scenario we need to use Apex Callout instead of Outbound Messages.
Option “The callout needs to be invoked from a Workflow Rule” is NOT CORRECT because we can use Apex Callout from the workflow rule.
Option “The target system uses a SOAP API” is NOT CORRECT because if the target system uses SOAP API, we can use both Apex Callout as well as Outbound Message.
Option “The callout needs to be asynchronous” is NOT CORRECT because for this scenario also, we can use either Apex or Outbound Message.
Option “The target system uses a REST API” is CORRECT because for this situation, we should only use Apex Callout.