Apex fundamentals, and the governor limits that shape every design

Apex is Java-shaped and database-flavoured. This module is the syntax, the tooling, and the parts that surprise people from other languages.

1. VideoSetting up: CLI, an editor, and running your first anonymous blockPreview9 min
2. VideoTypes, collections and the sObject8 min
3. VideoControl flow, exceptions, and Apex-specific behaviour8 min
4. VideoClasses, interfaces and the sharing keywords8 min
5. ReadingReading the debug log without losing an afternoon6 min
6. VideoThe generic sObject, and the trap of casting it wrong7 min
7. LabLab: write and run your first class12 min

SOQL, SOSL and DML. Written for correctness under bulk from the first line, because retrofitting bulk safety is a rewrite.

1. VideoSOQL: relationships, aggregates and the selective query9 min
2. ReadingSOSL, and the searches SOQL cannot do6 min
3. VideoDML, Database methods, and partial success8 min
4. VideoBulk by default: sets, maps, and never querying in a loopOne hundred SOQL queries per transaction. A query inside a loop over 200 records is not slow, it is a hard failure.8 min
5. VideoCollections: List, Set and Map, and choosing the right one7 min
6. VideoRelationship queries: parent-to-child and child-to-parent in one line6 min
7. LabLab: refactor a record-at-a-time class into a bulk one12 min

The limits that apply to every button click and page load. Most of them never bite until the org has real data volume.

1. VideoThe per-transaction limit table, and the six that actually bite9 min
2. VideoSOQL rows, query count, and the limit nobody hits until year two6 min
3. VideoCPU time, and the operation that is free in a trigger and expensive in a loop6 min
4. VideoDML rows, DML statements, and why one big update beats two hundred6 min
5. VideoReading a LimitException back to the line that caused it7 min
6. LabLab: instrument a transaction and read its limit consumption11 min

The limit set resets when code goes async, and that reset is a resource, not a loophole. Knowing what changes is the whole module.

1. VideoTwo limit sets, not one: what changes when code goes async7 min
2. VideoHeap size, and the collection that grows quietly6 min
3. VideoCallout limits inside a trigger, and why there are none5 min
4. VideoFuture methods get their own limits, and why that matters5 min
5. ReadingReading: the official limit tables, side by side5 min
6. ReadingReading: choosing sync or async before you write a line4 min
7. QuizCheck: limits and where they apply11 min

The heart of the course. Every callout in one transaction shares 120 seconds. A limit you design around is an architecture; a limit you discover in production is an incident.

1. VideoThe 120-second cumulative callout budgetEvery callout in one transaction shares 120 seconds. That single number sets your batch size, your timeouts and what has to move off-platform.9 min
2. VideoA worked example: timeouts of 25, 45 and 60 secondsA real integration, sized so three sequential calls cannot exceed the budget even at their worst. The numbers were chosen, not inherited.9 min
3. VideoThe 90-second wall-clock stop, and why it is never 1207 min
4. VideoSizing a batch against a budget every record in it shares6 min
5. VideoWhat has to move off-platform, and why6 min
6. LabLab: budget three sequential callouts against 120 seconds12 min

Future, queueable, batch and scheduled. Four tools, four limit sets, and a decision table you can keep.

1. VideoFuture methods, and why they are almost never the answer6 min
2. VideoQueueable, chaining, and the finalizer8 min
3. VideoBatch Apex, scope sizing, and stateful batches8 min
4. VideoScheduled Apex, and the job that failed unnoticed for nineteen days7 min
5. VideoChoosing between future, queueable, batch and scheduled6 min
6. LabLab: convert a synchronous job into a batch and verify 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 is how it stops being yours.

1. VideoWhy bulk safety is not optional on this platform6 min
2. VideoThe two-hundred-record trigger context, and designing for it from line one6 min
3. VideoMaps built once, not queried per record6 min
4. VideoA bulk-safe SOQL pattern you can reuse5 min
5. ReadingReading: the bulkification checklist5 min
6. LabLab: break a class with two hundred records, then fix it12 min

Two query languages, and the difference is not stylistic. One is selective and fast, the other searches text across objects.

1. VideoSelective queries, and the index that makes one selective7 min
2. VideoAggregate queries: GROUP BY, HAVING, and a rollup without a trigger6 min
3. VideoSOSL across multiple objects in one search6 min
4. VideoDynamic SOQL, and the injection risk it opens6 min
5. ReadingReading: how the query optimizer chooses a plan5 min
6. LabLab: write a selective query against a million-row object15 min

Every limit taught so far eventually shows up as a stack trace. This module is how you read one without guessing.

1. VideoReading a stack trace to the line that actually failed8 min
2. VideoDebug logs: levels, categories, and turning off what you do not need6 min
3. VideoGovernor limit exceptions, and the message that names the limit7 min
4. VideoApex Replay Debugger, checkpoints and variable inspection6 min
5. ReadingReading: common exception types and what each one means5 min
6. LabLab: diagnose a failing transaction from its log alone15 min

A capstone class that has to be bulk-safe, budget-aware and readable, then the check that confirms it landed.

1. VideoPutting it together: a bulk-safe, budget-aware Apex class7 min
2. VideoCommon first-year Apex mistakes, named6 min
3. VideoWhere Apex fits next: triggers, components and tests5 min
4. ReadingReading: the governor limits quick-reference card5 min
5. LabLab: build and instrument a small integration end to end15 min
6. QuizCheck: Apex fundamentals and limits12 min