Hard Difficulty Questions

Total heap size allocation

Why wrong: Heap size limits apply to total memory usage, not specifically the number of query statements executed.

Maximum CPU time on Salesforce servers

Why wrong: CPU time can increase, but the SOQL query governor limit is the primary direct violation.

Total number of records retrieved by SOQL queries

Why wrong: While record limits exist, the query count limit is hit first at 100 executions.

Execute the query using Database.queryWithBinds() with a restricted access modifier.

Why wrong: Database.queryWithBinds does exist, but string concatenation with bind syntax is the correct concept; the modifier option is a distractor.

Use String.escapeSingleQuotes() on all user inputs before concatenating into the query string.

Why wrong: While it helps with single quotes, bind variables are the definitive best practice and more secure.

Enclose all dynamic parameters in single quotes within the dynamic SOQL query string.

Why wrong: This approach is vulnerable to SOQL injection if the user input contains quote characters.

Standard Page Layout Editor

Why wrong: Page Layout Editor configures field placement, not code execution.

Lightning App Builder

Why wrong: Lightning App Builder configures app pages graphically.

SELECT Hierarchy FROM User

Why wrong: This query syntax is invalid.

USING SCOPE subordinate

Why wrong: USING SCOPE is used for views like mine, team, etc., not role hierarchies.

WITH ROLE HIERARCHY

Why wrong: WITH ROLE HIERARCHY is not a valid SOQL clause.

for(KeyValue kv : myMap.entrySet()) { ... }

Why wrong: Apex does not have a KeyValue or entrySet structure similar to Java.

for(Account acc : myMap) { ... }

Why wrong: You cannot iterate directly over a Map variable without specifying .keySet() or .values().

for(Id id : myMap.iterator()) { ... }

Why wrong: Maps do not have an iterator() method called this way for direct for-loop iteration.

Database.insert(records, AccessType.ENFORCE_ACCESSIBLE)

Why wrong: ENFORCE_ACCESSIBLE throws an exception rather than stripping inaccessible fields.

Approval.lock()

Why wrong: Approval locking is used for record approval processes, not FLS enforcement.

Schema.sObjectType.fields.isAccessible()

Why wrong: This is a boolean check method, not a method that strips data.

Omitting LIMIT clauses on large queries to ensure all records are fetched at once.

Why wrong: Omitting limits on unbounded tables can cause heap size and row limit violations.

Placing SOQL queries inside helper methods called within loops.

Why wrong: Putting queries inside loops is an anti-pattern that violates query limits.

Disable FLS checks in user profile settings before executing queries.

Why wrong: Modifying profiles is an admin configuration task, not an Apex development pattern for enforcing security.

Execute queries inside an asynchronous @future method.

Why wrong: Asynchronous methods run in system context, bypassing user-level sharing rules.

Use the 'without sharing' keyword on all transaction controllers.

Why wrong: 'without sharing' explicitly disables sharing rule enforcement.

webservice class without sharing

Why wrong: webservice keyword is for SOAP services, and without sharing bypasses security.

public class with sharing

Why wrong: REST services must be declared as global, not public.

private class inherited sharing

Why wrong: Private classes cannot be exposed as REST endpoints.

Declaring every class with 'without sharing'.

Why wrong: without sharing bypasses security and increases vulnerability.

Relying solely on Lightning Web Component HTML rendering tags.

Why wrong: Client-side hiding does not secure server-side Apex queries or DML operations.

AsyncException

Why wrong: AsyncException is related to asynchronous job queueing limits.

LimitException

Why wrong: LimitExceptions are thrown when governor limits such as CPU time or queries are exceeded, not specifically for callouts after DML.

SystemException

Why wrong: SystemException is a base class, not the specific exception thrown for this violation.

Only the failing test class is ignored.

Why wrong: A failure blocks the whole deployment package.

The deployment succeeds but flags a warning.

Why wrong: Tests are mandatory for production deployments.

The deployment continues but prevents Apex compilation.

Why wrong: Metadata API enforces test success for deployment.

Query inside a for-loop iterating over Trigger.new

Why wrong: Querying inside a loop will quickly exceed the 100 SOQL query limit.

Query each record individually using Limits.getQueries() checks

Why wrong: Checking limits does not prevent queries from exceeding the maximum limit if executed per record.

Use an asynchronous future method for every individual record

Why wrong: Spawning an asynchronous job per record will exceed future method execution limits.

Execute a separate SOQL query for every child record individually.

Why wrong: This violates bulkification and governor limits.

Always use SELECT FIELDS(ALL) to ensure all data is retrieved.

Why wrong: SELECT FIELDS(ALL) is restricted and generally inefficient for bulk Apex code.

Catching a DmlException inside a try-catch block.

Why wrong: Catching an exception prevents rollback of preceding successful code unless manually triggered.

Executing Database.insert(records, false) with partial failure.

Why wrong: Using false allows successful records to commit without rolling back.

The flow fails

Why wrong: Recursion is allowed as long as limits are not exceeded.

The trigger is queued for later

Why wrong: It executes synchronously.

The trigger is ignored

Why wrong: Triggers always fire unless disabled.

Annotate the trigger with @ReadOnly to increase the query limit.

Why wrong: The @ReadOnly annotation is only valid for read-only Batch Apex and scheduled methods, not standard triggers.

Wrap the query in a try-catch block and catch the QueryException.

Why wrong: Catching an exception will not prevent the governor limit from terminating the transaction.

Use the Database.executeBatch method to process each account in a separate transaction.

Why wrong: Batch Apex is meant for massive data volumes, but triggers must be bulkified directly rather than launching batches inside them.

@api

Why wrong: @api marks properties as public API fields exposed to parent components, but does not wire data automatically.

@track

Why wrong: @track makes private property mutations reactive within the component, but is not used for wire service data.

@readonly

Why wrong: @readonly is an Apex annotation, not a JavaScript decorator for Lightning Web Components.

Assign all queried records to a single global List variable in the class.

Why wrong: Incorrect. Storing all records in a single list easily leads to heap size limit exceptions for large datasets.

Set the method execution context to read-only using @ReadOnly.

Why wrong: Incorrect. Queueable classes cannot be annotated with @ReadOnly.

Permanent production status with unlimited user licenses.

Why wrong: Scratch orgs are temporary environments with short lifespans (maximum 30 days usually) and limited licenses.

Directly modifying standard Salesforce platform source code.

Why wrong: Standard platform source code cannot be modified, only metadata configurations.