Async Apex, and the job that stopped with exit code zero

Future, queueable, batch, scheduled and platform events all move work off the transaction. They are not interchangeable, and the constraint that binds is different every time.

1. VideoChoosing between future, queueable, batch, scheduled and platform eventsPreview9 min
2. VideoFuture methods: the narrowest tool, and when it is still right7 min
3. VideoQueueable as the default: chaining, context, and the finalizer7 min
4. VideoBatch Apex when the volume will not fit in one transaction, ever6 min
5. VideoPlatform events when more than one subscriber needs to know6 min
6. LabLab: pick a tool for four real jobs and defend each choice13 min

A chain that never stops is not a feature. This module is the depth limit, and the design that respects it on purpose.

1. VideoChaining queueables, and the depth limit that ends the chain8 min
2. VideoPassing state forward without a static variable6 min
3. VideoThe finalizer, and catching a chain that failed silently6 min
4. ReadingReading: a queueable chain, drawn as a diagram5 min
5. VideoAsyncOptions and the callback that confirms a chain finished5 min
6. LabLab: build a three-step queueable chain that survives one failure13 min

A batch job that dies in chunk 40 and repeats the first 39 on retry is not restartable. This module is the design that makes it one.

1. VideoWriting a batch job that is restartable, not just resumable8 min
2. VideoScope sizing, and the query locator that has to stay stable7 min
3. VideoStateful batches, and the one static total that is safe to keep6 min
4. VideoIdempotent execute methods, so a retried chunk does not double-count6 min
5. ReadingReading: Database.Stateful, used sparingly5 min
6. LabLab: kill a batch mid-run and restart it without double-processing14 min

A crash should lose one batch, not a night. That single design decision is the difference between an incident and a rerun.

1. VideoPosting results back in batches, so a crash loses one batch, not a night8 min
2. VideoCommitting progress as you go, instead of at the very end6 min
3. ReadingReading: a batch design that fails safely, walked chunk by chunk5 min
4. ReadingReading: choosing a commit granularity for a long-running job5 min
5. LabLab: rebuild a single-commit job to post results incrementally13 min

A scheduled sync stopped for about twelve hours: exit code zero, no error, roughly fifty missed cycles, while accounting queued invoices and watched nothing happen.

1. VideoThe job that stopped with exit code zeroLoaded, exit code zero, no error, roughly 50 missed cycles, while accounting queued invoices and saw nothing happen for about twelve hours.9 min
2. VideoWhy exit code zero with no error is the most dangerous failure mode7 min
3. VideoA digest that died with an auth error and ran 19 days unnoticed7 min
4. ReadingReading: the failure modes that never throw5 min
5. LabLab: reproduce a silent stop and confirm nothing alerts on it13 min

Silence is not success. Build the heartbeat before you need it, because the alternative is a controller finding out first.

1. VideoSilence is not success: build the heartbeat before you need it8 min
2. VideoA heartbeat object, stamped on every successful cycle6 min
3. VideoAn hourly watchdog that alerts on a missed check-in6 min
4. VideoMoving a job off one machine, and what that buys and costs6 min
5. ReadingReading: designing an alert that reaches a person, not a log5 min
6. LabLab: build a heartbeat and a watchdog for a scheduled job13 min

A scheduled job is easy to start and easy to forget. This module is what makes it supportable a year later.

1. VideoScheduled Apex: cron expressions, and jobs that skip a run cleanly8 min
2. VideoRescheduling and cancelling a job without leaving an orphaned trigger6 min
3. VideoNaming and documenting a scheduled job so it survives its author leaving6 min
4. VideoThe scheduled job nobody remembers exists, found in an audit5 min
5. ReadingReading: an inventory of every scheduled job in an org, and why one exists5 min
6. LabLab: audit a scheduled job for what happens when it fails13 min

Async code that only "usually" tests the same way is not tested. Test.startTest and a scheduled-job test are how it becomes deterministic.

1. VideoTesting asynchronous code deterministically8 min
2. VideoTest.startTest and Test.stopTest, and what actually runs between them7 min
3. VideoTesting a scheduled job without waiting for its cron to fire6 min
4. VideoTesting a heartbeat: forcing a missed check-in and asserting the alert6 min
5. ReadingReading: a pre-ship checklist for an asynchronous job5 min
6. LabLab: write a deterministic test for a batch-and-schedule pair13 min
7. QuizCheck: async Apex and observability13 min