Salesforce CRT-450 Exam Questions

The error message 'Maximum trigger depth exceeded' occurs when a trigger invokes itself recursively more than the allowed limit.

Option C: The trigger is getting executed multiple times.

Correct Answer.

This error indicates that the trigger is recursively calling itself.

This can happen if the trigger performs an update or insert operation that causes the same trigger to fire again, leading to an infinite loop.

Salesforce enforces a limit on the recursion depth to prevent stack overflows.

User permissions do not cause the 'Maximum trigger depth exceeded' error.

Option B: The trigger is too long and should be refactored into a helper class.

*Incorrect, but possible code improvement.

While refactoring code into helper classes is a good practice, it does not directly address the recursion issue causing the error.

Option D: The trigger does not have sufficient code coverage.

Incorrect.

Code coverage issues affect deployment but do not cause runtime errors like 'Maximum trigger depth exceeded'.

Conclusion:

The error is caused because the trigger is getting executed multiple times due to recursion, leading to exceeding the maximum trigger depth.

Triggers and Order of Execution

Preventing Recursive Triggers

Incorrect Options:

Option A: The developer does not have the correct user permission.

Incorrect.

To fire an exception in Apex, the developer must use the throw statement along with an instance of the exception.

Option A: throw new ParityException();

Correct Way.

Creates a new instance of ParityException with no message and throws it.

Syntax is correct for throwing an exception.

Option C: throw new ParityException('parity does not match');

Correct Way.

Creates a new instance of ParityException with a custom message and throws it.

The exception class inherits from Exception, which allows passing a message to the constructor.

Options Not Correct:

Option B: new ParityException('parity does not match');

Incorrect.

This statement creates a new instance of ParityException but does not throw it.

Without the throw keyword, the exception is not fired.

Option D: new ParityException();

Incorrect.

Similar to Option B, this creates a new instance but does not throw it.

The exception will not affect the flow unless it is thrown.

Conclusion:

The two ways the developer can fire the exception are:

Option A: throw new ParityException();

Option C: throw new ParityException('parity does not match');

Both use the throw statement to fire the exception.

The requirement is for service agents to gather many pieces of information when processing damaged or stolen credit cards.

Option A: Screen-based Flow

Correct Answer.

A Screen Flow allows developers to build guided, interactive forms that collect information from users.

Flows can have multiple screens, validation rules, and branching logic.

They can be created declaratively without code, making them efficient to implement.

Benefits:

Efficient Development: No need for code.

User-Friendly: Provides a step-by-step interface.

Maintainable: Easy to update as requirements change.

Building a custom Lightning Component requires development effort.

For simple data collection, a Flow is more efficient.

Option C: Approval Process

Incorrect.

Approval Processes are used for routing records for approval, not for gathering information from users.

Option D: Apex Trigger

Incorrect.

Triggers run in the background and are not used for interactive user interfaces.

Conclusion:

The most efficient way to satisfy the requirement is to use a Screen-based Flow, which is Option A.

Build a Flow

Screen Flows

Incorrect Options:

Option B: Lightning Component

*Possible but Less Efficient.