Process Automation And Logic practice questions

Queueable

Why wrong: Queueable is a separate asynchronous interface.

InstallHandler

Why wrong: InstallHandler is for managed package post-install scripts.

Batch Apex automatically rolls back the entire 50-million record job if a single record in one chunk fails.

Why wrong: Batch jobs fail per chunk unless allOrNone is handled or partial saves are configured; the entire job doesn't necessarily roll back unless aborted.

500 future methods per Apex transaction

Why wrong: 500 exceeds the future call limit.

10 future methods per Apex transaction

Why wrong: 10 is incorrect.

100 future methods per Apex transaction

Why wrong: 100 is the SOQL query limit, not future method calls.

Implementation of the Database.AllowsCallouts interface automatically.

Why wrong: Incorrect. Callouts are not automatically enabled and require explicit interface implementation.

Future methods can accept sObjects or lists of sObjects as parameters.

Why wrong: Future methods cannot accept sObjects as arguments because record state might change before execution; primitive types or collections of primitives must be used.

Future methods must be static and return either void or a primitive type.

Why wrong: Future methods must return void; they cannot return any value, primitive or otherwise.

Future methods can be called from within another future method.

Why wrong: Future methods cannot call other future methods to prevent infinite asynchronous chaining loops.

Database.executeBatch()

Why wrong: Batch Apex can be called, but queueable chaining specifically uses System.enqueueJob.

apexJob.schedule()

Why wrong: Scheduled jobs use System.schedule, not enqueueJob.

Future.runAsync()

Why wrong: Future methods cannot be chained directly in this manner.

Total heap size (6 MB)

Why wrong: Heap size limits are related to large data structures, not necessarily loop queries.

Total number of records retrieved by SOQL queries (50,000)

Why wrong: The record row limit is less likely to be hit by single-record queries in a loop than the query count limit.

Total CPU time (10,000 milliseconds)

Why wrong: While CPU time increases, the SOQL query limit is the primary direct governor limit violated by queries in loops.

System validation rules run after Before Triggers but before custom validation rules.

Why wrong: Custom validation rules run after Before Triggers, but system validations run before.

Before Triggers execute before system validation rules.

Why wrong: System validation rules run before the before triggers to ensure basic field-level integrity.

Before Triggers and system validation rules run concurrently.

Why wrong: Execution is strictly sequential in Salesforce triggers and validation steps.

Trigger.isExecuting

Why wrong: Trigger.isExecuting returns true whenever code is running in trigger context, regardless of operation.

Trigger.isBefore

Why wrong: Trigger.isBefore checks if the trigger runs before the record is saved, not the DML type.

Trigger.isInsert

Why wrong: Trigger.isInsert returns true only for insert operations.

@TestSetup

Why wrong: TestSetup is used to create test data.

@InvocableMethod

Why wrong: Invocable methods are used for Process Builder and Flows.

@ReadOnly

Why wrong: ReadOnly is used for batch reporting and increasing query limits.

500

Why wrong: 500 is incorrect; the limit is 100.

50

Why wrong: 50 is too low; the limit is higher.

250

Why wrong: 250 exceeds the maximum limit for scheduled jobs.

After Insert

Why wrong: After triggers are read-only for the source records and require DML to update them.

After Update

Why wrong: After update triggers run after the record is committed and require explicit DML statements.

Before Undelete

Why wrong: Before undelete is used for records being restored from the recycle bin.

Queueable Apex

Why wrong: Queueable Apex is better for chained jobs and complex data types rather than massive 2-million record chunks.

Future methods

Why wrong: Future methods cannot accept complex objects and are not suited for multi-million record processing loops.

Scheduled Apex

Why wrong: Scheduled Apex is used for time-based triggers, which typically invoke Batch Apex to do the heavy lifting.

60,000 milliseconds

Why wrong: 60,000 milliseconds is the asynchronous limit.

120,000 milliseconds

Why wrong: 120,000 milliseconds exceeds standard limits.

5,000 milliseconds

Why wrong: 5,000 milliseconds is incorrect.

After After Triggers

Why wrong: Validation rules always run before data is saved in database transactions, long before after triggers.

Before Before Triggers

Why wrong: Validation rules run after before triggers have a chance to modify data.

Concurrently with After Triggers

Why wrong: Triggers and validation rules run in a strict serial order.

Trigger.old

Why wrong: Trigger.old is a list, not a map.

Trigger.new

Why wrong: Trigger.new is a list of the new versions of records.

Trigger.newMap

Why wrong: Trigger.newMap contains the new versions of records.

When performing complex callouts to external REST APIs.

Why wrong: Callouts from flows have limitations and Apex is typically favored for intricate callout integrations.

When writing custom web service classes for external clients.

Why wrong: Web service classes require Apex REST annotations.

When processing millions of records nightly in batches.

Why wrong: Batch processing requires Batch Apex.

Scheduled Apex

Why wrong: Schedulable execute methods only accept a SchedulableContext parameter.

Future methods

Why wrong: Future methods only support primitive data types and collections of primitives.

Trigger asynchronous execution blocks

Why wrong: Triggers do not have a dedicated asynchronous execution block feature.

Database.allowsCallouts

Why wrong: allowsCallouts is used for making callouts, not error handling.

System.abortJob()

Why wrong: abortJob cancels the entire batch job.

Database.rollback()

Why wrong: Rollback completely aborts the transaction, preventing partial commits.

Always query inside a for loop for every record.

Why wrong: Querying inside loops violates bulkification principles and hits limits.

Use future methods for every trigger execution.

Why wrong: Using future methods blindly causes unnecessary asynchronous job queueing.

Hardcode record IDs in trigger logic for performance.

Why wrong: Hardcoding IDs causes deployment and environment promotion failures.