Course 2.10 · Curriculum 2026.1
Async Apex, and the job that stopped with exit code zero
Move work off the user’s transaction, then prove it is still running. Built around a scheduled sync that stopped for about twelve hours with exit code zero and no error, roughly fifty missed cycles, while accounting queued invoices and watched nothing happen.
- Estimated effort
- 6 hr
- Lessons
- 47
- Modules
- 8
- Material
- 6 hr
Estimated effort is the sum of the lesson and lab times in this version of the course. It is not video runtime, which is lower.
Canadian dollars. One learner, lifetime access to this course version. Tax extra.
1 lesson free to preview
This course does not issue a certificate on its own. It counts toward the paths listed below, and those do.
01What you will learn
8 capabilities, stated as things you can do
Each one is what you should be able to do at the end, not what the course covers. If an outcome is not testable, it is not an outcome.
- Choose between future, queueable, batch, scheduled and platform events by the constraint that actually binds.
- Chain queueables without hitting the depth limit or losing work on a crash.
- Write a batch job that is restartable, so a failure in chunk 40 does not repeat the first 39.
- Post results back in batches, so a crash loses one batch rather than a night.
- Stamp a heartbeat and alert on absence, because silence is not success.
- Explain why exit code zero with no error is the most dangerous failure mode you will meet.
- Move a job off one machine, and say what that buys and what it costs.
- Test asynchronous code deterministically, including the scheduled path.
02Curriculum
8 modules, 47 lessons
Every lesson shows its length and its type. A SCORM lesson looks like any other lesson, which is the point of ingesting packages rather than linking out to them.
8 modules · 47 lessons · 6 hr of material
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.
- VideoChoosing between future, queueable, batch, scheduled and platform eventsPreview9 min
- VideoFuture methods: the narrowest tool, and when it is still right7 min
- VideoQueueable as the default: chaining, context, and the finalizer7 min
- VideoBatch Apex when the volume will not fit in one transaction, ever6 min
- VideoPlatform events when more than one subscriber needs to know6 min
- 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.
- VideoChaining queueables, and the depth limit that ends the chain8 min
- VideoPassing state forward without a static variable6 min
- VideoThe finalizer, and catching a chain that failed silently6 min
- ReadingReading: a queueable chain, drawn as a diagram5 min
- VideoAsyncOptions and the callback that confirms a chain finished5 min
- 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.
- VideoWriting a batch job that is restartable, not just resumable8 min
- VideoScope sizing, and the query locator that has to stay stable7 min
- VideoStateful batches, and the one static total that is safe to keep6 min
- VideoIdempotent execute methods, so a retried chunk does not double-count6 min
- ReadingReading: Database.Stateful, used sparingly5 min
- 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.
- VideoPosting results back in batches, so a crash loses one batch, not a night8 min
- VideoCommitting progress as you go, instead of at the very end6 min
- ReadingReading: a batch design that fails safely, walked chunk by chunk5 min
- ReadingReading: choosing a commit granularity for a long-running job5 min
- 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.
- 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
- VideoWhy exit code zero with no error is the most dangerous failure mode7 min
- VideoA digest that died with an auth error and ran 19 days unnoticed7 min
- ReadingReading: the failure modes that never throw5 min
- 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.
- VideoSilence is not success: build the heartbeat before you need it8 min
- VideoA heartbeat object, stamped on every successful cycle6 min
- VideoAn hourly watchdog that alerts on a missed check-in6 min
- VideoMoving a job off one machine, and what that buys and costs6 min
- ReadingReading: designing an alert that reaches a person, not a log5 min
- 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.
- VideoScheduled Apex: cron expressions, and jobs that skip a run cleanly8 min
- VideoRescheduling and cancelling a job without leaving an orphaned trigger6 min
- VideoNaming and documenting a scheduled job so it survives its author leaving6 min
- VideoThe scheduled job nobody remembers exists, found in an audit5 min
- ReadingReading: an inventory of every scheduled job in an org, and why one exists5 min
- 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.
- VideoTesting asynchronous code deterministically8 min
- VideoTest.startTest and Test.stopTest, and what actually runs between them7 min
- VideoTesting a scheduled job without waiting for its cron to fire6 min
- VideoTesting a heartbeat: forcing a missed check-in and asserting the alert6 min
- ReadingReading: a pre-ship checklist for an asynchronous job5 min
- LabLab: write a deterministic test for a batch-and-schedule pair13 min
- QuizCheck: async Apex and observability13 min
03Before you start
What you need first
Assumed knowledge and setup
- Course 2.1. The limit set and the asynchronous vocabulary are assumed.
- Course 2.7 helps, because half of this course is about proving a job ran.
- A Developer Edition org and the Salesforce CLI.
Courses that come first
- 2.1 · Apex fundamentals, and the governor limits that shape every design8 hr · Intermediate
Part of these paths
- Salesforce DeveloperShareCo Certified Developer
- The Full StackShareCo Certified Platform Engineer
04Who teaches it
Elliot Saha
Co-founder, Chief Technology Officer
Platform architecture, custom Apex and Lightning Web Components, AI systems, and the Academy platform itself.
05Reviews
No learner reviews yet
This course has not been taken by enough people to publish an honest rating, and we will not print invented quotes on a page that sells verification discipline. Here is what we can evidence instead.
- Assessment
- Lesson checks onlyThis course carries lesson checks. The certificate is issued by the path assessment, not by this course.
- Curriculum version
- 2026.1You enrol into a version. Content changes do not move you mid-course, and your required-lesson count is snapshotted at enrollment.
- Refunds
- 14 daysFull refund within 14 days if you have completed under a quarter of the required lessons. Stated here rather than in a footer.
Start 2.10
Enrol as an individual, or buy seats and assign this course to your team. Progress is reported per lesson, per module and per path.
- 6 hr estimated effort, labs included
- Lifetime access to the version you enrol in
- A ShareCo certificate is not a Salesforce certification