Triggers, handlers and bulk safety

Nineteen steps run between a user clicking save and the record existing. Knowing the order explains almost every "why did that happen" ticket.

1. VideoThe order of execution, walked step by stepPreview9 min
2. VideoTrigger contexts, and choosing before over after8 min
3. VideoWhere flows, validation rules and triggers interleave8 min
4. VideoRollup summaries and cross-object formulas in the order6 min
5. ReadingReading: the order of execution, as a reference page5 min
6. VideoThe trigger.old and trigger.new maps at each stage5 min
7. LabLab: predict then verify the save order in your own org14 min

The rule stated first because it is the one that stops a second developer from ever writing a second trigger on the same object.

1. VideoOne trigger per object, and why two is a race condition8 min
2. VideoNaming and locating the one trigger so nobody adds a second6 min
3. VideoVendor-managed triggers, and why they stay out of source control7 min
4. VideoConfirming a trigger is the only one on an object before deploying5 min
5. LabLab: find every trigger on one object in a real org11 min

All logic in a testable class, none of it in the trigger body. This is the single decision that keeps a codebase reviewable.

1. VideoA handler class you can unit test without DML8 min
2. VideoDispatching by trigger context to one method per event6 min
3. ReadingTrigger frameworks: what they buy and what they cost6 min
4. VideoDependency injection so a handler is testable in isolation6 min
5. VideoSplitting a handler method per trigger context cleanly5 min
6. LabLab: refactor a 300-line trigger into a handler14 min

A trigger that re-fires itself is not a bug in the platform. It is a static variable that was never reset, or never set.

1. VideoRecursion guards, and the static that is not reset8 min
2. VideoThe trigger that fires twice, diagnosed7 min
3. VideoWhen recursion is correct, and guarding it anyway6 min
4. VideoA static guard reset between test methods, and the bug that hides5 min
5. LabLab: cause a recursive update, then guard against it12 min

A trigger that works on one record and fails on two hundred is the most common defect in a Salesforce codebase. This module removes it.

1. VideoTrigger.new, Trigger.oldMap, and the maps you should build once8 min
2. VideoBulkifying a handler so two hundred records cost the same queries as one7 min
3. VideoThe query-in-a-loop defect, found in review6 min
4. ReadingReading: a bulk-safety checklist for a trigger review5 min
5. ReadingReading: the addError message a user actually sees4 min
6. LabLab: break a handler with a bulk load, then fix it13 min

allOrNone false, and the rule that an order must never fail to save because a follow-up task could not be created.

1. VideoaddError, partial success, and not rolling back the whole load8 min
2. VideoAn order must never fail to save because a follow-up task could not be created8 min
3. VideoDatabase.insert with allOrNone false, and reading the results back7 min
4. VideoLogging a partial failure so it is diagnosable later6 min
5. VideoChoosing which DML method surfaces which kind of error5 min
6. LabLab: make a follow-up write fail without failing the parent save13 min

Roughly 191 active flows share these objects with 32 triggers. Deciding where logic lives is a daily decision, not a one-time design.

1. VideoCoexisting with roughly 191 active flows on the same objects8 min
2. VideoDeciding when logic belongs in a trigger, a flow, or neither7 min
3. VideoA flow and a trigger both writing the same field, diagnosed7 min
4. VideoA record edited by both a flow and a trigger in the same save5 min
5. ReadingReading: a decision table for trigger versus flow5 min
6. LabLab: trace a field update to the automation that made it12 min

A handler is only as good as the test that proves it survives two hundred records and a partial failure.

1. VideoTesting a trigger with 200 records, not one8 min
2. VideoTesting that a partial failure genuinely did not block the parent7 min
3. ReadingCode review checklist for a new trigger handler5 min
4. VideoPeer review: reading someone else’s handler for recursion risk5 min
5. LabLab: bring a handler to a passing bulk and partial-failure test11 min
6. QuizCheck: triggers and bulk safety15 min