Free Salesforce-Platform-Developer Practice Test Questions (2026)

Explanation:

Why A (using extends and override) is correct:

Inheritance (extends): In Apex, Payment is defined as a virtual class. Classes that are virtual (or regular classes) are inherited using the extends keyword. The implements keyword is reserved exclusively for interfaces, not classes.

Method Overriding (override): The method makePayment in the parent class is marked as virtual. To provide a subclass-specific implementation of a virtual method, the subclass must explicitly use the override keyword.

Why the other options are incorrect:

Using implements with a class: You cannot use implements on a class unless it is an interface. implements will trigger a compilation error when applied to a class definition.

Reference
Salesforce Apex Developer Guide: Inheritance (Virtual and Abstract Classes)
Salesforce Apex Developer Guide: Overriding Methods

Explanation:

Option C: String.escapeSingleQuotes()

String query = 'SELECT Id FROM Account WHERE Name LIKE \'%' + String.escapeSingleQuotes(name) + '%\'';
List results = Database.query(query);

Why Safe?

String.escapeSingleQuotes() sanitizes the input by escaping single quotes (' → \').
Prevents attackers from breaking the query with malicious input (e.g., name = "test' OR Name != ''").

Option D: Bind Variable

String query = '%' + name + '%';
List results = [SELECT Id FROM Account WHERE Name LIKE :query];

Why Safe?
Bind variables (:query) are automatically escaped by Salesforce.
No string concatenation = no injection risk.

Why Not the Others?

Option A: Unsafe Concatenation

String query = 'SELECT Id FROM Account WHERE Name LIKE \'%' + name + '%\'';

Risk: Direct concatenation allows SOQL injection (e.g., if name = "test' OR Name != ''").

Option B: noQuotes() (Invalid Method)
String query = 'SELECT Id FROM Account WHERE Name LIKE \'%' + name.noQuotes() + '%\'';

Risk: noQuotes() doesn’t exist in Apex. Even if it did, it wouldn’t escape quotes.

Explanation: Scheduling a Data Export job is the best way to back up all the data and attachments in a Salesforce org once a month. The Data Export job can be scheduled to run at a certain frequency so that the data can be backed up on a regular basis. This makes it easy to restore the data in case of any emergency.

Explanation:

Why B is correct: Lightning components (both LWC and Aura) run on the client-side (the browser) and do not have direct access to the database or SOQL. To perform database operations, complex queries, or relationships/joins between objects, developers must write server-side Apex code. Exposing an Apex method with the @AuraEnabled annotation makes it callable from the Lightning component.

Why the other options are incorrect:

A (Flow): While Flows can be invoked from Lightning components, writing complex server-side queries or multi-object joins is best practice and most efficiently handled in Apex.

C (LWC wrapper): Client-side components cannot execute database queries directly without a server-side backend.

D (Streaming API): The Streaming API is used for real-time event subscription (such as PushTopics or Change Data Capture), not for executing standard database queries on demand.

Reference:
Salesforce Apex Developer Guide: Using @AuraEnabled Annotation
Lightning Web Components Developer Guide: Calling Apex

Explanation:

To ensure that the Lightning Web Component (LWC) displays only the fields the current user is allowed to see, based on field-level security (FLS), you should use:

✅ Security.stripInaccessible() in Apex

This method:

Removes fields from queried records that the user doesn’t have read access to
Ensures the component does not throw errors or expose restricted data
Allows a single Apex method to return different sets of data depending on user permissions

🔍 Example:

List salesRecords = [SELECT Id, Name, Commission__c FROM Sales__c];
salesRecords = (List) Security.stripInaccessible(AccessType.READABLE, salesRecords).getRecords();
return salesRecords;

❌ Why other options are incorrect:

A. Use WITH SECURITY_ENFORCED
❌ This will throw a runtime exception if a user lacks access to a field in the query.
Not ideal when you want to show partial data based on user permissions.

C. Use Lightning Data Service
❌ LDS respects FLS but is typically used for single-record forms, not for querying lists of records.

D. Use Lightning Locker Service
❌ Locker Service is a security layer for JavaScript isolation, not for enforcing data visibility or FLS.

Explanation:

The issue here is that the Visualforce page is exceeding the View State limit because it's trying to display a very large dataset (10,000+ Container__c records). To fix this efficiently, the developer should:

✅ Use a StandardSetController to paginate the data.

This approach:

Loads and displays a subset of records at a time (e.g., 50 per page)
Keeps the view state small and manageable
Is the most declarative and Salesforce-recommended way to paginate in Visualforce

🔍 Example:

public with sharing class ContainerPaginationController {
public ApexPages.StandardSetController setCon {
get {
if (setCon == null) {
setCon = new ApexPages.StandardSetController(
[SELECT Id, Name FROM Container__c WHERE Account__c = :ApexPages.currentPage().getParameters().get('id')]
);
setCon.setPageSize(50);
}
return setCon;
}
set;
}

public List getContainers() {
return (List) setCon.getRecords();
}
}

❌ Why other options are less appropriate:

A. JavaScript Remoting with SOQL OFFSET
❌ OFFSET is inefficient at large scale (10,000+ records)
Also requires custom JavaScript and Apex code

C. OffsetController
❌ Not a standard Salesforce controller — likely refers to a custom implementation, which is more complex and error-prone

D. Lazy loading and transient List
❌ transient helps reduce view state, but by itself won’t fix the issue
Lazy loading requires custom logic, still won't handle paging automatically

Explanations:

A. Bulk API & Storage Limits

True. Bulk API is optimized for large data volumes (up to 10k records/batch) but does not bypass storage limits.
Storage limits (e.g., data, file storage) are enforced in all environments, including sandboxes.

C. Sandbox Storage Limits

True. Salesforce sandboxes have tiered storage:

Developer Sandbox: 200 MB data + 200 MB file storage.
Developer Pro Sandbox: 1 GB data + 1 GB file storage.

Why the Others Are False:

B. Bulk API Bypassing Limits
False. No tool (Bulk API, Data Loader, etc.) can bypass Salesforce storage limits.

D. Data Import Wizard as a Client App
False. The Data Import Wizard is a built-in Salesforce UI tool (accessible via Setup), not a separate client application.

Explanation:

The Data Import Wizard is a user-friendly, web-based tool in Salesforce, but it has limited object support. Specifically:

🔹 The Data Import Wizard does not support importing Opportunity records.

Instead, it supports standard objects like:

Leads
Contacts
Accounts
Campaign Members
Custom objects
To import Opportunities, a developer must use a tool like the Data Loader.

❌ Why the other options are incorrect:

A. Data Loader runs from the developer's browser
❌ False: Data Loader is a client application that runs on your desktop, not in a browser.

C. Data Loader automatically relates Opportunities to Accounts
❌ False: You must explicitly map the AccountId field or provide matching criteria — it doesn’t happen automatically.

D. Data Import Wizard cannot import all 500 records
❌ False: It can handle more than 500 records — limits depend on the object and user profile, but 500 is well within its capacity.

Explanation:

In Next Best Action (NBA) with Einstein Recommendations, when using the Enhance element to call an Apex method, the method must meet specific requirements defined by the InvocableMethod interface.

🔒 Requirements for @InvocableMethod used with Enhance:

Must be global static

Must accept a List input
Must return a List> (typically List>)
NBA expects multiple recommendation results per input record

🔍 Why Option D is correct:

✅ Uses @InvocableMethod
✅ Declared as global static
✅ Input is List → valid
✅ Output is List> → matches the required return type for Enhance in NBA

❌ Why the other options are incorrect:

A. Missing static keyword → ❌
B. Return type is List instead of List> → ❌
C. Input is not a list, return type is a single object → ❌

Explanation:

The anonymous block attempts to query and update 50,000 Case records:

for(Case thisCase : [SELECT Id, Status FROM Case LIMIT 50000]){
thisCase.Status = 'Working';
casesToUpdate.add(thisCase);
}

Then it performs a bulk update:

Database.update(casesToUpdate, false);

However, Salesforce enforces a strict governor limit:

❗ Maximum DML rows per transaction: 10,000

This code updates 50,000 records, which exceeds the limit, and will cause the transaction to fail with a "Too many DML rows" exception.

❌ Why the other options are incorrect:

B. The try/catch block will handle any DML exceptions thrown
❌ Partially true — it can catch exceptions, but governor limit exceptions are uncatchable once hit.

C. The transaction will succeed and changes will be committed
❌ False — It will exceed the 10,000 DML rows limit and fail.

D. The try/catch block will handle exceptions thrown by governor limits
❌ False — Governor limit exceptions are not catchable. Once a limit is hit, the transaction is immediately halted.