PROGRAM DOC | MHA INSTRUCTOR PLAYBOOK MATERIAL HANDLING ACADEMY

Material Handling Academy Professional Training Program

The Instructor Playbook

The master facilitation document. Every part, every lesson, the whole method.

Subject Matter Expert: Michael Collins

Instructor Version | Confidential

How To Use This Document

This is the one document you read before you teach anything in the Academy. It won't teach you conveyor. It teaches you how an MHA lesson works, what the journey is supposed to leave in a student, and how to run each of the thirty-five lessons without being the person who wrote them. The standard is simple: an instructor who is not Michael should be able to teach any lesson with authority from its session plan and this playbook.

Read Section 1 once and keep it. Read the per-lesson note for whatever you're teaching that day, and read the part note before you start a new part. Section 4 is instructor-only and stays that way. Nothing in this document is ever handed to a student, quoted to a student, or left on a projector when the room walks in.

Section 1 The Method: How an MHA Lesson Works

Every lesson in the program is built on the same seven-step anatomy and the same set of devices. Learn the shape once and every session plan reads the same way.

FIELD INSIGHT | MICHAEL COLLINS

This isn't conveyor training. Conveyors are the medium. What we're teaching is engineering judgment, the ability to analyze a problem, communicate a solution, design it, and defend it. If a lesson sounds like corporate training when you teach it, you're teaching it wrong. It should sound like one experienced engineer talking to another on the floor.

The seven-step anatomy

Every lesson runs these seven steps in order. The student pages are built this way, the slides follow it, and your session plan is timed against it. Don't reorder it and don't skip a step.

Header and Driving Question. A gold banner states the real engineering question the lesson answers, plus one "by the end you can" line. It replaces the old learning-objectives list. The Driving Question is the whole point of the lesson made visible. Put it on the board and don't answer it until the room has earned it.
Journey strip. All eight parts with "you are here" lit, plus a line naming what the student carries in from the lesson before. It replaces the prerequisites list and it keeps the single-story structure alive: nothing in the program exists in isolation.
The hook. Story before theory. A field scenario or the next Riverside beat, cold, with no context-framing prose. You open on the problem, not on a paragraph about why the problem matters.
Teaching blocks. One idea per block, tight prose, worked examples, devices placed inline at the exact decision they serve. Standards tables live in the companion guides and get referenced, never reprinted.
Riverside Project strip. The spiral-notebook exercise that applies the lesson to Riverside Distribution Co. and produces a real deliverable. It's styled like a notebook page on purpose: the medium invites keeping it. Every lesson has at least one.
Forest Through the Trees. The closer, kept by name. Zoom out, connect backward and forward, put the day's work back in the context of the whole system. Always return to the forest; never stay in the weeds longer than the lesson needs.
Checkpoint. Two or three scenario questions with judgment answers. Recall drills moved to the worksheets. The Checkpoint is where you find out whether they can think, not whether they memorized.

The device roster: what each one is FOR

Devices aren't decoration. Each one does a specific job at a specific moment. Here's what each is for and how to run it.

Device	What it's for, and how you run it
Driving Question	The real engineering question the lesson exists to answer. Put it on the board at the open. It's the law that says every lesson answers a real question or it shouldn't exist, made visible.
The Three W's	A decision card: three navy chips (Why / When / Where) plus two dark-red chips (Not When / Failure If Ignored), attached to every major concept. Run it as a guessing game. Have the room guess the W's before you reveal the card. Their misses are the teaching. It doubles as a recap.
Field Insight	A navy card with Michael's photo and a real story from the field. It carries the voice and the experience. Read it in his register, blunt and specific, not as a bullet point.
Pro Tip (Field Move)	A gold-bordered box, signed MC, structured If you see X / do Y / tradeoff / verify. It's a move that accelerates a decision. Placed at the decision it speeds up, never as a general tip.
Common Mistake	A red-edged box placed exactly where the mistake happens, not in a summary. It replaces the old pitfalls wall. Name the error and the fix, plainly.
Design Principle	A simple gold box holding one boxed law, like "flow before equipment." Say it out loud and make the room repeat it. These are the lines the program is remembered by.
Controls Corner	A blue-edged box, Part IV only. It answers one question: how is this specific hardware controlled? It's a preview that hands the depth forward to Part V by name. Don't turn it into a controls lecture.
Stop and Think	A small box with a short exercise, no calculator and no answer given. Let the silence sit. The point is to make them commit to a position before anything gets revealed.
Think Like the Package	The carton's point of view. What does the box experience here, does it rotate, accelerate, stop, tip? It's the one method the whole program leans on. Make them narrate it out loud.
Think Like the Operator	The person's point of view: safety, maintenance, clearing a jam at 2 AM. Introduced in force in Part VI. It's how a design gets checked against the human who has to work beside it.
Riverside Project	The spiral-notebook strip that threads the capstone through every lesson from day one. It produces a deliverable each time. See Section 4 for why the notebook styling matters.

The 60-minute run-of-show discipline

Every instructor session plan carries a run of show broken into timed segments that sum to sixty minutes. That number is a discipline, not a suggestion. The failure mode is spending forty minutes framing and ten minutes on the live exercise where the learning actually happens. Front-load the framing and you starve the moment that lands the lesson.

Protect the key teaching moment. In almost every lesson it's a live exercise, a board sketch, a roleplay, a calculator run, and it's the segment that earns the hour. If something has to give, cut the recap and the framing, never the exercise. Each plan also carries stretch options that extend the session to a 90-minute block. Use those to go deeper, not to pad.

How Checkpoints are graded

Checkpoints are two or three scenario questions on the student page, and they never contain their own answers. The answer key and the judgment guidance live in the instructor file only. That's deliberate: the student can't reverse-engineer the answer from the page, and you keep the authority to grade the reasoning rather than the recall.

Grade the thinking, not the vocabulary. A student who reaches the wrong conclusion by sound reasoning has done more than one who lands the right word with no path behind it. Recall drills moved to the worksheets on purpose, so the Checkpoint stays a judgment test. When you grade, say why an answer works or doesn't, in plain terms.

The facilitation voice

Spoken, blunt, field-first. Every page is written as one experienced engineer teaching another, so teach it that way. Use contractions. Tell a real story from your own work where the plan calls for one. When a student is wrong, say so directly and redirect, don't soften it into a maybe. The room respects a straight answer more than a comfortable one.

Field-first means the story comes before the theory and the floor comes before the slide. When you can put a real building, a real carton, or a real failure in front of the room instead of a definition, do it. The definitions are on the page. Your job is to make the room feel the problem before they name it.

Section 2 The Journey: The Eight-Part Arc

The program is one story told across eight parts. Each part carries something in from the part before it and leaves one thing behind in the student. If a student can't tell you what they carried in, the connective tissue broke and you need to repair it before you go on.

Think Like a Solutions Professional

Leaves behind: the lens. The student stops seeing equipment and starts seeing problems, operations, and people. The job is judgment, not hardware.

Carry in Nothing but curiosity. This is where the program starts. Carry out The requirements document v1: the confirmed problem, in writing, that everything after designs against.

Understand the Product

Leaves behind: the think-like-the-package reflex, and the discipline that a min and a max aren't design inputs until you know the volume behind each.

Carry in The requirements document, with the product profile buried inside it. Carry out The MTBH table and the design-envelope recommendation.

III

Understand Flow

Leaves behind: the flagship principle, flow before equipment. The student maps how material moves before naming a machine.

Carry in The MTBH table and envelope: the products this flow has to carry. Carry out The four-layer flow diagram and explicit rate targets. This is the document every later part builds on.

Design the Conveyance

Leaves behind: the habit of selecting equipment on the inputs, not on a favorite. Category first, naming second. Every hardware lesson closes with a Controls Corner.

Carry in The rate targets and the bottleneck map from the flow diagram. Carry out Technology selections with justification.

Make the System Intelligent

Leaves behind: the five-layer topology and the instinct to ask which layer owns a decision. This is the depth part; controls don't get oversimplified here.

Carry in A system built almost entirely in steel, still waiting to be told what to do. Carry out The controls architecture summary, the setpoints list, and the interface map.

Validate the Design

Leaves behind: the margin habit and the proof discipline. The calculator was never the answer; judgment is. Prove it before you sign it.

Carry in A complete system on paper, controls and all, every number off a calculator that assumed a perfect world. Carry out The validation package and the guarding audit.

VII

Communicate the Design

Leaves behind: the standard that a proposal is engineering communication, not sales. Engineering that can't be communicated doesn't get built.

Carry in The validated design, proven on paper and audited for people. Carry out The proposal package: drawing, business case, and proposal, ready for the room.

VIII

Deliver the Solution

Leaves behind: the line between finishing the program and being ready to run one alone, plus the tools for the first ninety days.

Carry in The approved proposal package, about to become steel on a floor. Carry out The commissioning plan, and the whole arc handed off to the Capstone, where the student runs it unscaffolded.

Section 3 Per-Lesson Notes: All 35 Lessons

One compact block per lesson. For the full run of show, key teaching moment, and watch-fors, open that lesson's instructor session plan. This is the fast read before you walk in: the one thing that has to land, the failure you'll most likely have to catch, the Riverside deliverable the lesson produces, and where the clock gets tight.

Part IThink Like a Solutions ProfessionalPart deliverable: requirements document v1

The Profession

DQ: Whose problem am I actually here to solve?
Must land: The job is judgment, not equipment. If they walk out naming hardware instead of naming problems, it didn't land.
Failure: Students equate the job with knowing models and answer every question with a machine. Ask back what problem that solves for Dana. The catalog is step ten, not step one.
Deliverable: A dated Riverside project note holding the one question they'd prepare before calling Dana back.
Timing: "The job in one sentence" (10m) is the heart. Don't let "the players" walk or the Three W's game crowd it out.

The Warehouse Ecosystem

DQ: How does a warehouse actually work?
Must land: Look at a real building and see flow, not equipment. Reciting the five tasks off a slide isn't the lesson; placing them on a floor is.
Failure: Memorizing the five tasks as vocabulary, and classifying flow from a company's size or name instead of the material path. Send them back to how product actually moves.
Deliverable: Riverside flow classification, simple / medium / complex, with a two-sentence justification from what Dana actually said.
Timing: "Draw the warehouse" (12m) is the session. Guard it from ABC rotation and verticals eating the clock.

Reading an Operation

DQ: What is this operation telling me before anyone speaks?
Must land: Read people, flow, and the physical state of the place before proposing anything. Stop reaching for equipment.
Failure: Coming back from a walk with an equipment inventory, taking Dana's stated ask as the whole job, and walking past dead automation without asking its story.
Deliverable: Riverside facility readout: stated ask vs observed need, the two dead systems, a maintenance team of one, the mezzanine constraint.
Timing: Eight segments in 60 leaves no slack. Keep the meeting hook at 6m so the two reads and the key moment survive.

Customer Discovery

DQ: What problem am I actually trying to solve?
Must land: Discovery is a conversation you steer, not a checklist you read.
Failure: Interrogation-style questioning, firing the six categories like a form. Jumping to a solution the moment a familiar symptom lands. Skipping a question to avoid looking green.
Deliverable: requirements document v1, the Part I deliverable everything after designs against.
Timing: The first-question roleplay (12m) and the requirements ritual (12m) both carry weight. If the roleplay slips, the document gets squeezed.

Part IIUnderstand the ProductPart deliverable: MTBH table + envelope recommendation

Think Like the Package

DQ: What is it like to be the package?
Must land: The reflex to trace a product's ride through the system, out loud, before drawing a line. The phrase isn't the answer; narrating one carton at one transfer is.
Failure: Treating "think like the package" as a slogan, or reaching for a conveyor type before analyzing the box.
Deliverable: A behavior read of the four Riverside products: which runs easy, which is a handling risk, which to flag.
Timing: The carton-ride board exercise (12m) and the Riverside read (13m) are the spine. Don't lecture either.

The MTBH and the Design Envelope

DQ: Which products should this system actually be built around?
Must land: A min and a max aren't design inputs until you know the volume behind each.
Failure: Sizing straight to the customer's two extremes, producing an MTBH table with no volume column, and setting the envelope silently instead of taking it to the customer.
Deliverable: Riverside MTBH table, two named outlier candidates (Small and Large Case), and an envelope recommendation.
Timing: The live outlier demo (14m) is where it lands. Keep the min/max board work from running long.

The Product Decision Chain

DQ: Can this product be conveyed, and in what order do I find out?
Must land: Reason the decision chain before opening the tool. The Product Spec Calc is step five, never step one.
Failure: Reaching for the calculator first, treating outputs as final answers, and running conveyor math on what's really a goods-to-person or ASRS problem.
Deliverable: A decision-chain walkthrough on Riverside's data, calc last, with every output tied to a package they already named.
Timing: The live calc demo (16m) is the longest block. Make a student drive it under pressure; don't just show it.

Part IIIUnderstand FlowPart deliverable: four-layer flow diagram + rate targets

Flow Before Equipment

DQ: What does material actually do in this building, before I draw any equipment?
Must land: Describe how material moves in plain language before naming a single machine. Flow before equipment.
Failure: Reaching for a conveyor run the moment they see a floor plan, and drawing equipment when you asked for flow.
Deliverable: Riverside Layer 1 process flow diagram, blocks and arrows, confirmed as a story read out loud.
Timing: "Draw the flow from the floor plan" (15m) is the lesson. Protect it; the compare-across-the-room is where the gaps show.

The Layered Flow Diagram

DQ: How does a flow diagram grow into the design map?
Must land: The diagram grows in rounds without changing format. By Layer 4 it carries enough to drive every downstream decision.
Failure: The people-in-the-layout miss, Layer 4 with no operator on it, and vague buffer notes like "some accumulation here" instead of measurable requirements.
Deliverable: Riverside four-layer flow diagram, Layers 2 through 4, with the three data questions planted at each smart decision point.
Timing: The live layer build (14m) plus Layer 3 and 4 (20m) fill the hour. Keep the Layer 1 recap at 4m.

L10

Rate and Bottlenecks

DQ: Will this flow still hold when the rate gets real?
Must land: A calculator output is a starting point for judgment, not a specification. The margin habit.
Failure: Strong-math students who run a clean number and skip margin, skipping the five-question stress test because the flow "looks clean," and drifting into sorter speed (that's L25).
Deliverable: Riverside rate targets table (20 CPM split 55/35/10) plus the five-question stress-test results.
Timing: The margin exercise (12m) and the three outputs live (12m) are the core. Hold the line before the class wanders into sorter math.

Part IVDesign the ConveyancePart deliverable: technology selections with justification

L11

How Conveyors Work

DQ: How does a conveyor actually work, and what in it decides whether it lasts?
Must land: A part you can name but can't say what wears in is a part you don't understand. Every component answers to a product decision and has to be reachable.
Failure: Treating the parts list as trivia, going silent on maintenance, and jumping to picking a category (that's L12).
Deliverable: A component-and-maintenance read of Michael's two failures: what kind of machine failed and why, in this building.
Timing: The anatomy walk (16m) and "what fails, where the wrench reaches" (14m) are the session. Don't let category selection start early.

L12

Transportation vs Accumulation

DQ: Does this point in the system move product, or does it hold product?
Must land: Transportation and accumulation are functions, not conveyor types, and the mechanism behind an accumulation platform matters as much as the category.
Failure: Treating EZ as a brand, picking a mechanism on unit price, and memorizing "electric good, pneumatic bad." Correct that last one out loud; the question is whether the building's air is stable, not good vs bad.
Deliverable: Riverside transportation-vs-accumulation map plus a technology direction justified by the two failures.
Timing: The naming drill (8m) has to hit reflex speed. Selection drivers live (14m) is the longest block.

L13

Accumulation Design

DQ: How much accumulation does this buffer need, and how should it release?
Must land: Turn a buffer requirement into a zone count and length, and choose a release mode on purpose instead of trusting the default.
Failure: Understanding the concept but stalling at the number, designing zones and forgetting the Aux I/O, and leaving release on default. Make "where are your Aux I/O points" automatic on every layout.
Deliverable: Riverside accumulation zone plan: zone count, zone length, release mode, and the weight-per-zone MDR check.
Timing: Sizing on the board (16m) is the core. The Riverside plan (12m) is where the Aux I/O question has to fire.

L14

Changing Direction and Elevation

DQ: What happens to the package when the system has to turn, climb, or drop?
Must land: Run the static number, then ask what the package feels in motion. This lesson runs as two class sessions: curves, then elevation.
Failure: Speccing the run first and fitting a curve into it, treating the static tumble angle as the whole safety check, and checking only the centered load.
Deliverable: Riverside mezzanine decline design: angle in the 40 ft run, tumble check on the Tall Case, thirds method on the shifted load.
Timing: Two 60-minute sessions. Curves and the guardrail taper fill Session A. The thirds method is Session B's five-minute move that prevents a five-day field fix.

L15

Transfers and Merges

DQ: What breaks when product changes direction, or two flows become one?
Must land: After a 90-degree transfer the package travels hard-way even though it never rotated. Watch the package, not the conveyor.
Failure: Carrying trunk roller centers onto the takeaway, waving off the frame gap, fixing stopping drift with a better delay instead of clearance, and not being able to say why air feeding a merge is uncontrolled induction.
Deliverable: Riverside merge configuration plus the transfer note with recomputed hard-way takeaway roller centers.
Timing: The transfer block (16m) and merges (14m) carry the hour. The orientation question is the pivot, so wait for the room to turn it.

L16

Sortation

DQ: Which sorter does this operation actually need, no more and no less?
Must land: Right-sizing. Run product, throughput, footprint in that order against the full mix, no favorites.
Failure: Selecting on the majority product and skipping the edge case, selecting on average throughput, carrying a previous project's sorter forward, and quoting a universal pph scale.
Deliverable: Riverside sorter selection with the matrix evaluation and every technology ruled out and why.
Timing: The product-type matrix (16m) is where it lands. The controls mini-brief opens the lesson (5m) because Part V depth comes later.

L17

The Automation Landscape

DQ: When is conveyor the right answer, and when is it the wrong one?
Must land: Zoom out and ask the honest question, out loud, before a line gets drawn: was conveyor even the right tool?
Failure: Can't zoom out from the conveyor they just built, treating alternatives as threats to dismiss, forgetting environment as a selection driver, and quoting a made-up adoption or payback number.
Deliverable: Riverside automation-landscape review: alternatives considered, why conveyor fits, and what would have changed the answer.
Timing: "Argue the wrong tool" and "when conveyor is not the answer" (14m) do the work. Keep it category-level, no fabricated numbers.

Part VMake the System IntelligentPart deliverable: controls architecture + setpoints + interface map

L18

Control Philosophy

DQ: Which layer of the system owns this decision?
Must land: The five-layer topology in their head, drawn from memory, with the right owner on each layer and the instinct to ask which layer owns this.
Failure: Reciting the five names but not what moves between them, defaulting every problem to "it's the PLC," and treating WCS and WES as the same thing.
Deliverable: Riverside controls-topology placement: each component on its layer with the owner named, and the WMS-latency open item flagged.
Timing: The live topology build (14m) stays on the board the whole hour. The placement round-robin (12m) is the test.

L19

Sensing and Identification

DQ: How does the system know what a package is and where it is?
Must land: A decision is only as good as the read it's made from. This isn't a parts tour.
Failure: Treating identification as "just a scanner" and skipping presence and registration, assuming 100 percent reads, and naming an encoder without explaining why an upstream scan still diverts on time.
Deliverable: Riverside sort-point sensing plan: registration photoeye, barcode read, encoder, and the no-read destination.
Timing: The photoeye drawn live (14m) is the center. The registration point has to visibly move before the rule stops being a slogan.

L20

Machine Controls

DQ: How does a decision become motion the machine can execute safely?
Must land: The machine controls layer is specified now, in writing, or it gets defaulted at startup and the system underperforms.
Failure: Treating Aux I/O as trivia because they met it in L13, conflating the safety PLC with the standard PLC, and leaving release modes and ramp rates "for commissioning."
Deliverable: Riverside machine-controls / Aux I/O list plus the first setpoints: belt speeds, VFD ramp, PLC delays, release modes, fail-safe default.
Timing: The Aux I/O mapping drill (14m) and safety PLC (12m) are the depth. Don't reduce the mechanisms to slogans.

L21

Power and Networks

DQ: What keeps the system powered, connected, and defended?
Must land: Power and networks aren't the electrician's or IT's problem; they're design decisions a solutions engineer has to catch. The names are exact: EtherNet/IP and CIP Safety.
Failure: Disengaging as if it's "the electrician's problem," blurring EtherNet/IP and CIP Safety, and assuming an OT network patches like a laptop.
Deliverable: Riverside power-and-network note: two voltage domains, network segments, EtherNet/IP and CIP Safety assignment, remote-access owner, OT-network owner.
Timing: Segmentation, remote access, and OT cybersecurity (17m) is the longest block. The flat-network war-game is where it lands.

L22

Data and Decisions

DQ: What has to move between systems, how fast, and what happens when it doesn't arrive?
Must land: Response time between systems is a physical design constraint, not a software setting. It travels back through belt speed, gap, and scan-to-divert distance.
Failure: Reciting the handshake but "fixing" a doubled latency by editing only software, treating response time as a setting to tune later, and skipping the confirmation step.
Deliverable: Riverside interface map plus the latency budget worksheet, run at the confirmed 1-second WMS response.
Timing: The handshake and failure taxonomy (14m) plus the live Ray recalculation (14m) are the hour. Make the room find every number that moves.

L23

Recovery, Diagnostics, and the Operator

DQ: When it jams, stalls, or goes dark, how does the system recover?
Must land: Every failure mode needs a designed destination and a designed recovery, not a dead stop and a shrug.
Failure: Drawing the hospital lane as an unsized box, thinking anti-gridlock is pure software, "handling" a WMS outage by stopping the line, and designing a restart that surges a zone back to life.
Deliverable: Riverside recovery-and-exception plan, which closes the controls architecture summary, setpoints list, and interface map together.
Timing: Sizing the hospital lane live (13m) and degraded mode / restart (12m) carry the close. Keep the exception-volume math a real number, not a placeholder.

Part VIValidate the DesignPart deliverable: validation package + guarding audit

L24

The Perfect World Problem

DQ: Where does the calculated answer stop being true, and how much margin does it need?
Must land: A calculator output is a perfect-world baseline. Find where the real world bends it and how much margin it needs before you sign.
Failure: Treating outputs as final answers with no margin, checking only the centered load, not knowing whether they're in solutioning or final engineering, and seeing a peer call as admitting ignorance.
Deliverable: Riverside worst-case validation note: the Tall Case decline re-check under inertia and load shift, the margin call, and two peer-review triggers.
Timing: The slippage and inertia demos (12m + 14m) build the whole margin habit. Keep the two final-engineering runs for L25.

L25

The Gap Check and Capacity Proof

DQ: Does this system actually hit its rate, and does the gap survive every check?
Must land: The 16-step sequence order isn't optional, and the required rate drives every number on the sorter tab, so it's confirmed in writing first.
Failure: Running the sorter tab before confirming the rate, speccing the takeaway spur at sorter speed, skipping the transfer gap check because the sorter passed, and adding lane rates as if the merge were free.
Deliverable: Riverside capacity proof plus the setpoints package, with the scan-to-divert distance re-run at the confirmed 1 second.
Timing: "Run it, then break it" (18m sorter block) is the lesson. Change the rate after the calc is done and watch every sorter number go wrong while each still passes its own check.

L26

Reliability Engineering

DQ: When this system fails, how fast is it back up, and can this customer keep it running?
Must land: Reliability is designed, not specified. Find failure modes first, rank by cost, stock spares by criticality, match the customer's actual maintenance team.
Failure: Designing for an ideal PM team the customer doesn't have, stocking one of everything, treating failure frequency as the only metric, and setting MTBF off a datasheet.
Deliverable: Riverside reliability plan: FMEA from the two observed failures, criticality ranking, spares by criticality, MTBF/MTTR targets set with the customer.
Timing: FMEA it live (13m) then "spares and the team you actually have" (16m). The maintenance-reality question is where it lands.

L27

Validate for People

DQ: Is this system safe for the person who works beside it and fixes it at 2 AM?
Must land: Safety is a scoping discipline, and underside guarding is decided by exposure, never a fixed height.
Failure: Citing a fixed height as a guarding exemption, treating safety as a final-engineering checklist, speccing a cage from a "cobot" label instead of the risk assessment, and putting a standard limit switch on a safety gate.
Deliverable: Riverside guarding audit, every category turned into a priced line, feeding the proposal's safety scope.
Timing: Read the fact-check correction note before you teach. The mezzanine layout hunt (12m) turns on stopping the "above 96 inches so it's exempt" reflex on the spot.

Part VIICommunicate the DesignPart deliverable: the proposal package

L28

The Drawing Is the Plan

DQ: Can every trade build their scope from this drawing without calling me?
Must land: The drawing is the plan, and the pre-release call to every trade is how you find what's missing while it still costs nothing to add.
Failure: Treating the drawing as a picture, assuming trades will ask if something is missing, and not being able to name a specific callout when asked what a trade needs.
Deliverable: Riverside installation drawing package: trade callouts plus the RFQ completeness check on all three vendors.
Timing: The pre-release interview, taught then run live (16m), is the session. Drive every student to one specific missing callout.

L29

The Business Case

DQ: Does this system pay for itself, and can I prove it?
Must land: The business case is built from confirmed inputs, not assumed labor numbers and not against an industry-standard payback that doesn't exist.
Failure: Presenting a payback on unconfirmed headcount, quoting "two to four years" as a norm, excluding an outlier without pricing it, and treating the business case as sales.
Deliverable: Riverside business case structure against Tom's three-year threshold, priced outlier options, and the ask-Tom-in-writing list.
Timing: Payback and the honest range (16m) plus pricing the outlier both ways (16m) fill the hour. Run at least one payback live.

L30

The Proposal

DQ: Does this proposal give the customer enough to make a real decision?
Must land: A proposal is engineering communication, not a sales pitch. Its job is to give the customer enough accurate information to make a real decision, limitations included.
Failure: Treating the proposal as persuasion, softening or burying a limitation, skipping the maintenance section, and self-reviewing their own checklist.
Deliverable: The Riverside proposal package, the Part VII deliverable, gate-cleared and handed to an independent reviewer.
Timing: The buried-limitation roleplay (13m) and the gate / peer-review (14m) are the anchors. Teach the disclosure standard until they feel it.

L31

The Room

DQ: Who is in the room, and how deep do they need me to go?
Must land: One set of documents serves a technical, a business, and a maintenance buyer at once, if you lead with outcomes and put the executive summary first.
Failure: Leading a business buyer with model numbers, going thin when a technical buyer challenges, ignoring the maintenance seat, and treating presenting as persuasion.
Deliverable: Riverside presentation and defense plan: two executive summaries, the hardest question each of the three buyers will ask, and the outlier defense.
Timing: The two-summaries exercise (16m) and the live room (18m) carry it. A student who writes the same summary twice hasn't read the room.

Part VIIIDeliver the SolutionPart deliverable: the commissioning plan

L32

The Handoff

DQ: Before the first bolt turns, does everyone know what I know?
Must land: The first move after award isn't the vendor call, it's the handoff: a meeting plus a released drawing that surfaces the non-obvious decisions before mobilization.
Failure: Treating the handoff as an email instead of a meeting, confirming scope with the PM only, naming skeletons but not the trade interface where each gets dropped, and planning a cutover that assumes the operation can stop.
Deliverable: Riverside handoff package checklist: drawing release, pre-execution agenda, trade-interface list, scope confirmation, brownfield cutover with a rollback.
Timing: The meeting and the skeletons (16m) is the session. Brownfield cutover (12m) has to end with what still ships and the rollback.

L33

Execution Support

DQ: The build is live. What does the engineer still own?
Must land: A field change is never evaluated locally, and the as-built is a legal document.
Failure: Saying yes or no on the spot, evaluating a change locally and never tracing it downstream, treating redlines as end-of-project paperwork, and blurring the lane to own the schedule.
Deliverable: Riverside change-impact evaluation (the decline-landing shift) plus the redline / as-built plan.
Timing: The change-impact matrix and ripple (16m) is the core. Don't accept the first three effects as complete.

L34

Commissioning and Acceptance

DQ: How do we prove it works, and who keeps it running after we leave?
Must land: We own the FAT; the customer owns the SAT criteria. A service model a real maintenance team can't live with is a promise that breaks on the first bad night. Two sessions, one plan.
Failure: Treating FAT and SAT as the same test, accepting on one good run, designing an SLA a one-person team can't meet, and handing over spares with no criticality logic.
Deliverable: The Riverside commissioning plan, the Part VIII headline: FAT scripts, SAT criteria, rate-validation method, punch list, training, and the service model.
Timing: Two 60-minute sessions. Session A's SAT block (20m) drives sustained statistical acceptance, not a two-minute demo. Session B builds the service model for a team of one.

L35

Becoming the Engineer

DQ: I finished the program. Am I ready to run one alone?
Must land: Finishing the program isn't the same as being ready to run one alone. Draw the line, hand them the first-90-days tools, close on the letter.
Failure: Equating finishing with readiness, treating readiness as a calendar date, not being able to name what they don't know, and skipping the do-not-run-alone list out of confidence.
Deliverable: Readiness self-assessment against the five criteria, an escalation map with real names, and a first-90-days plan.
Timing: End on the letter, not logistics. The eight habits (10m) and Michael's closing letter (8m) close the program. Don't analyze the letter to death; let it land, then point them at the Capstone.

Section 4 The Project Folder (Instructor Only)

Instructor Only | The Quiet Payoff of the Whole Program

Here's the thing this whole program is quietly built around, and it never gets said to a student. Every Riverside strip in every lesson produces a real deliverable, and every one of them is styled like a spiral-notebook page on purpose, because the medium invites keeping it. A student who actually keeps them as they go, the requirements document from Lesson 4, the MTBH table and envelope from Lesson 6, the four-layer flow diagram from Lessons 8 through 10, the technology selections, the controls architecture, the validation package and guarding audit, the business case, the proposal draft, walks into the Capstone with most of the package already built. For that student the Capstone isn't a scramble. It's assembly. They lived the documentation discipline for thirty-five lessons and the folder they kept is the Capstone in draft.

You never announce this. Ever. Documentation discipline is taught openly, as what real engineers do, from the dated project note in Lesson 1 onward. But no student-facing text ever says "save this for the Capstone," and neither do you. The reveal belongs to the student. The ones who kept the folder should discover on their own that they've been building toward this the entire time. That discovery is the lesson, and if you hand it to them early you take it away.

Watch for it and reward it at the debrief. When a student arrives at the Capstone with an organized folder, name it in the debrief, out loud, so the room sees that the habit was the point. The students who didn't keep the folder will feel the difference the moment the Capstone asks for a deliverable they threw away. That's a lesson too, and it's a fair one, because the whole program told them the habit mattered. Use both outcomes to teach the documentation habit as a professional standard, not a trick.

The deliverable-to-capstone map

Every Capstone requirement traces back to a lesson deliverable the student already produced. This is the map. Keep it to yourself; use it to recognize, at the debrief, exactly what a student who kept the folder walked in already holding.

Capstone requirement	Drafted across	The deliverable already in the folder
Problem definition / discovery	L1, L3, L4	The dated project note, the facility readout, and the requirements document v1 that everything designs against.
Product Analysis and Design Envelope	L5, L6, L7	The product behavior read, the MTBH table with outlier candidates and envelope recommendation, and the decision-chain walkthrough.
Layer 1: Process Flow Diagram	L8	The Riverside Layer 1 process flow diagram, blocks and arrows, confirmed as a story.
Layer 2: Volume and Rate	L9, L10	The Layer 2 volume-and-rate notes plus the rate targets table (20 CPM, 55/35/10).
Layer 3: Decision Points and Smart Handoffs	L9	The Layer 3 smart decision points with the three data questions planted at each.
Layer 4: People and Constraints	L9	The Layer 4 buffers, people, forklift crossing, and mezzanine landing.
Mezzanine Decline Design	L14, L24	The decline design (angle, tumble check, thirds method) and the worst-case validation note under inertia and load shift.
Rate and Speed Calculations	L10, L25	The rate targets plus the capacity proof and the scan-to-divert distance at the confirmed 1-second latency.
Technology Selection with Justification	L12, L13, L15, L16, L17	The transportation-vs-accumulation map, accumulation zone plan, merge and transfer note, sorter selection, and automation-landscape review.
Safety and Guarding Summary	L27	The guarding audit, every category turned into a priced line.
Controls Architecture Summary	L18-L23	Topology placement, sensing plan, machine-controls / Aux I/O list, power-and-network note, interface map and latency worksheet, and the recovery plan, built one layer per lesson.
The Business Case	L29	The payback structure against Tom's three-year threshold, the priced outlier options, and the ask-Tom-in-writing list.
The Proposal Package	L28, L30, L31	The installation drawing package, the assembled six-part proposal (gate-cleared, independently reviewed), and the presentation and defense plan.
Commissioning Plan	L32-L35	The handoff package checklist, change-impact evaluation, the commissioning plan itself, and the readiness self-assessment.

Section 5 Running the Capstone

The Capstone is the Riverside Distribution Co. simulation run end to end, unscaffolded. It's a conversation with the student, not a submission, and it's where the whole program gets tested at once. Don't teach it from this playbook. The full scene-by-scene facilitation, the instructor notes on every decision point, the teaching moments to watch for, and the debrief structure all live in the Capstone instructor guide.

Run it from the Capstone Instructor Guide

Open academy/capstone/riverside-instructor-guide.html. It carries the scene structure, the "your move" decisions, the instructor notes on what each answer tells you about the student, the two teaching moments most engineers miss (the after-divert roller-center problem and the latency recalculation), and the debrief where you name the project-folder payoff from Section 4.

One dry note for the record before you teach this: the Michael Collins who has spent twenty years on the Riverside floor is not the Michael Collins who wrote this program. Same name, different man, and yes, we noticed. Handle it with one aside if a student catches it, and move on.

Section 6 First-Time Instructor Checklist

Three passes. Do the first one once, the second before every part, the third before the Capstone. It keeps a first-time instructor from teaching the words without the method.

Before Day One

Read Section 1 of this playbook in full. Know the seven-step anatomy and what every device is for before you teach a single lesson.
Read The MHA Way and be able to say all nine rules from memory. Every project and every lesson answers back to it.
Read the whole Riverside capstone student brief once, so you know where the program is going before you start it. You can't thread a story you haven't read the end of.
Accept the voice. Spoken, blunt, field-first. If your instinct is to lecture, rehearse against it. Have one real story from your own work ready for Lesson 1.
Understand the project-folder payoff in Section 4, and commit to never announcing it.

Before Each Part

Read the part note in Section 2: what the student carries in, and the one thing the part has to leave behind.
Read the per-lesson notes in Section 3 for every lesson in the part, and open each lesson's instructor session plan for the full run of show, key teaching moment, and watch-fors.
Confirm the carry-in. Ask the room what they walked in with. If they can't name it, repair the connection before you teach anything new.
Check the deferrals. Know what this part plants but does not teach, so you can redirect a student who runs ahead instead of letting the class wander.
For Part IV, remember every lesson closes with a Controls Corner. For Parts V and VI, read the binding fact-check corrections before you teach L21 and L27; don't teach a myth from memory.

Before the Capstone

Read the Capstone instructor guide end to end. Know the scenes, the decision points, and the two teaching moments most engineers miss.
Ask each student to bring their Riverside project folder. Don't tell them why. Watch who has one.
Plan the debrief. Name the deliverable-to-capstone map for the students who kept the folder, so the room sees the habit was the point all along.
Have the name-collision aside ready, in case a student catches it. One dry line, then move on.
Frame it as a conversation, not a test. The Capstone is the walkthrough made solo; your job is to review the reasoning with the student, not to grade a submission.