* Marking the field as required on the field definition ensures that the field is always populated during record creation or update. This enforces the rule at the database level.
* Other Options:
* Option A: Setting a default value ensures a value is present initially but does not enforce a value during updates.
* Option B: Writing a trigger is less efficient and adds unnecessary complexity.
* Option C: Marking the field as required on the page layout is UI-specific and does not enforce the rule during API or code-based operations.

* A. Unify all three triggers in a single trigger on the Expense__c object that includes all events:
* Salesforce best practices recommend having only one trigger per object to avoid redundancy and conflicts.
* By combining all the events (before delete, before insert, and before update) into a single trigger, the developer can manage the logic in an organized and maintainable manner.
* This also simplifies debugging and ensures that the trigger logic executes in a predictable order.
* C. Create helper classes to execute the appropriate logic when a record is saved:
* Using helper classes allows for a clean separation of concerns. The trigger becomes a dispatcher that delegates logic to dedicated classes.
* For example, you can create methods like applyDefaultsToExpense(), validateExpenseUpdate(), and deleteExpense() in a helper class and invoke them from the trigger.
* This improves reusability, readability, and testability of the code.
Why not the other options?
* B. Unify the before insert and before update triggers and use Flow for the delete action:
* While Flow is a powerful tool, it is not ideal for deleting records or replacing Apex trigger functionality, especially when triggers already exist for other events.
* D. Maintain all three triggers on the Expense__c object but move the Apex logic out of the trigger definition:
* Maintaining multiple triggers on the same object can lead to conflicts and execution order issues, even if the logic is moved to helper classes.
References:
* Trigger Best Practices
* Trigger Design Patterns

The correct implementation of the CheckPaymentProcessor class must adhere to the PaymentProcessor interface. To accomplish this:
* Use the implements keyword to signify that the CheckPaymentProcessor class is implementing the PaymentProcessor interface.
* Define the pay method in the CheckPaymentProcessor class, as it is required by the PaymentProcessor interface.
* The pay method must match the method signature defined in the PaymentProcessor interface (void pay (Decimal amount)).
Explanation of Option D:
* It uses implements PaymentProcessor to correctly indicate that the class adheres to the interface.
* The pay method is properly implemented with the required method signature and includes a placeholder for functional code.
Other Options:
* Option A: The pay method is not implemented correctly (no method body).
* Option B: Incorrect use of extends instead of implements (interfaces are implemented, not extended).
* Option C: Same issue as Option B, with a slight variation in formatting.

* B: @testSetup inserts data once and shares it across all test methods in the class, saving system resources.
* D: @isTest(SeeAllData=true) is incompatible with @testSetup due to their differing purposes for managing test data.

* Why Change Sets?
* Change Sets are the recommended and simplest way to deploy metadata, including Apex code and Lightning Components, from Sandbox to Production.
* Why Not Other Options?
* A: The Force.com IDE is deprecated.
* B: The Ant Migration Tool is more suitable for complex deployments but not necessary for standard Sandbox-to-Production migration.
* D: Salesforce CLI is effective for deployment but requires scripting expertise, making Change Sets easier for most users.
* Change Sets: https://help.salesforce.com/s/articleView?id=sf.changesets.htm References: