Flow: the automation you will actually build

Six things are called a flow. Picking the wrong one is the most common reason an automation is slow or unmaintainable.

1. VideoScreen, record-triggered, scheduled, platform event and autolaunchedPreview6 min
2. VideoChoosing a trigger: a record change, a schedule, or a person clicking a button7 min
3. ReadingThe flow types you will use once a quarter, briefly6 min
4. VideoAutolaunched flows called from Apex, and why that boundary matters7 min
5. VideoPlatform event-triggered flows, briefly6 min
6. ReadingWhen a flow is the wrong tool6 min
7. LabLab: pick the right flow type for five real requests7 min

A before-save update writes fields on the record already in memory. No second DML, no second trigger pass, roughly ten times faster.

1. VideoBefore-save versus after-save, and the performance argumentA before-save update writes fields on the record already in memory. No second DML, no second trigger pass, roughly ten times faster.6 min
2. VideoWhat a before-save flow cannot do, and why7 min
3. ReadingFast Field Update, and the flow trigger explorer6 min
4. VideoOrder of execution: where a before-save flow actually runs7 min
5. VideoRecursion, and the update that triggers itself6 min
6. LabLab: convert an after-save field update into a before-save flow6 min

A formula field marked informational purposes only was in fact the entry criterion firing the entire order-side tax stack. Read the field, not the label.

1. VideoEntry criteria, and running a flow only when something changed7 min
2. VideoFormula fields as entry criteria, and what that quietly commits you to6 min
3. ReadingHelp text is not documentation, and the field that proved it7 min
4. VideoThe formula field whose help text said informational purposes onlyIts own help text read informational purposes only, not used in calculations. It was in fact the trigger for the entire order-side tax stack.6 min
5. VideoDisproving a diagnosis against every record, not the first one you check7 min
6. LabLab: trace an entry criterion back to the field it actually depends on6 min
7. VideoFixing an entry criterion without breaking every flow that already relies on it7 min

Variables, collections, loops and assignments. Written the way that stays readable when the flow is forty elements long.

1. VideoVariables, collections and the resource types7 min
2. VideoGet, loop, assign, update: the shape of almost every flow6 min
3. VideoDecisions, and why nested decisions are a smell7 min
4. ReadingFormulas inside a flow, and when to use one instead of a decision6 min
5. VideoConstants and the value you should never hardcode twice7 min
6. LabLab: build an approval-routing flow6 min
7. VideoReusing a flow’s logic without copying it6 min

Large screen flows are edited in Flow Builder and run end to end, never hand-edited as XML. This module says why that is not caution for its own sake.

1. VideoScreen flows: sections, columns and the components people actually use7 min
2. VideoValidation on a screen, and the error a user can act on6 min
3. ReadingWhy large screen flows are edited in Flow Builder and run end to end, never hand-edited as XMLA hand-edited element can save without ever being exercised by a real run. Flow Builder plus an end-to-end test catches what a text edit cannot.7 min
4. VideoDynamic forms on a screen flow, and the field that should not have been hardcoded6 min
5. VideoA screen flow that reported success while doing nothing7 min
6. LabLab: build a screen flow with a validated, branching form6 min

A forty-element flow is not one automation. It is several, tangled together. Subflows are how you untangle them without a rewrite.

1. VideoSubflows, and the forty-element flow that became three6 min
2. VideoPassing variables in and out of a subflow7 min
3. ReadingWhen a subflow is the wrong kind of split6 min
4. VideoVersioning a subflow without breaking every flow that calls it7 min
5. LabLab: refactor a long flow into a parent and two subflows6 min
6. VideoTesting a subflow in isolation before it is called by anything7 min

A schedule promises when a flow starts. It does not promise the flow finished, or that anyone would know if it did not.

1. VideoScheduled flows: what runs, and what a schedule cannot promise6 min
2. VideoScheduled paths on a record-triggered flow, briefly6 min
3. ReadingBatching a scheduled flow so it does not hit a limit at 2am7 min
4. VideoA scheduled flow with no failure alert, and the days nobody noticed6 min
5. VideoIdempotency in a scheduled flow: what happens if it runs twice7 min
6. LabLab: build a scheduled flow that only touches what changed6 min

The module that separates a flow that works in a demo from one that survives a data load. DML inside a loop is the whole lesson.

1. VideoWhat happens when 200 records save at onceA flow runs once per record but shares the transaction limits. A single update inside a loop is 200 DML statements against a limit of 150.7 min
2. VideoMoving DML and Get elements out of loops6 min
3. ReadingThe limit that is actually 150, and the operation that counts double6 min
4. VideoCollection filters instead of a Get inside a loop7 min
5. VideoBulkifying a decision element that branches per record6 min
6. LabLab: break a flow with a 200-record load, then fix it7 min
7. VideoTesting bulk safety before a data load, not during one6 min

A failure that nobody hears about is not handled. Fault paths, debug logs and a clean migration off Process Builder, in that order.

1. VideoFlow interviews, the debug log, and reading an error email7 min
2. VideoFault paths, and making a failure tell someone6 min
3. ReadingThe fault path that emailed an address nobody reads6 min
4. VideoMigrating a workflow rule or Process Builder without changing behaviour7 min
5. VideoRunning the migrated flow side by side before retiring the original6 min
6. LabLab: migrate a Process Builder process to a record-triggered flow7 min
7. VideoDeactivating the original without a gap where nothing runs6 min

Versioning, migration and the point where a flow should become Apex. The maintenance half nobody teaches until it costs a week.

1. VideoVersions, activation, and the deploy that reverted your change7 min
2. ReadingNaming and documentation that a stranger can read6 min
3. VideoThe handover line: when this should have been ApexComplex collection processing, callouts with real error handling, and anything needing a unit test. Flow can do the first two badly.6 min
4. VideoA flow inventory: what is active, what is orphaned, what can be deleted7 min
5. LabLab: refactor a 40-element flow into threeThe capstone lab for the course. Take a real forty-element flow and split it into a parent and two subflows.27 min
6. LabLab: prove the refactor changed nothing a user can seeA refactor nobody verified is a rewrite. Run the same records through the old flow and the new one, and treat any difference as a defect in the split rather than an improvement.26 min
7. VideoDocumenting a flow so the next admin does not have to open it to trust it6 min
8. QuizCheck: flow15 min