00 — How This Curriculum Works (Read This First

This is not a syllabus. This is an incident investigation program. You don't study topics. You solve crimes. Every concept you need for the interview is smuggled inside a real production incident — and the learning happens as a byproduct of wanting to know what actually happened and why.

1. Why this method (the science, 60 seconds)

Your instinct — top-down + problem-based + curiosity-driven — is backed by a lot of research. But the research also found the exact conditions under which it fails. This curriculum is engineered around both sides.

Research finding	What it means for you
Productive failure (Kapur, 2014 — Cognitive Science): students who attempted a hard problem before instruction matched direct-instruction on recall but crushed it on transfer. The number of solution attempts you generate predicts how much you learn.	You will attempt each incident before reading the answer. You are expected to fail. The failure is the task.
But pure discovery fails (Kirschner/Sweller/Clark, 2006): struggle without scaffolding = wasted effort. PBL + scaffolding beats unsupported PBL.	Every problem has a time cap, a hint ladder, and an ironclad reveal. You never struggle aimlessly.
The magic is the contrast (Loibl/Roll/Rummel, 2017): comparing your wrong attempt vs. the canonical solution is the single confirmed mechanism.	Every reveal is written as a contrast: "your hypothesis #1 breaks because…"
Retrieval practice (Rowland: g=0.50; Adesope: g=0.61) and spacing (Cepeda: +10–30%) are the only "high utility" techniques.	Each module ends in a closed-book drill; you re-test at 1-day / 1-week / 1-month. Judge progress ONLY by delayed retrieval, never by how smooth a session felt. (The "fluency illusion" — sessions that feel easy teach the least.)
Curiosity = memory amplifier (Kang 2009: caudate activation; Gruber 2014: 70.6% vs 54.1% recall for high-curiosity material). Curiosity needs a specific, named gap — "complete ignorance creates little curiosity."	Each incident opens with a named mystery: "Why did the developer's `LIMIT 1` not fix it?"
Advance organizers (Ausubel; Mayer): a conceptual bridge (not an agenda) at higher abstraction anchors the details.	Each module opens with a one-screen big-picture map.
Generation effect (Slamecka & Graf): producing > reading, always.	You write your attempts. You never read a summary first.
Interleaving (Rohrer & Taylor: test scores 20% → 63%): mixing topics trains discrimination — choosing the right tool.	Reviews mix previous modules; you must choose the technique before solving.
Narrative (2024–2026 studies): stories provide relational structure memory needs.	Incidents are framed as 2–3 sentence stories with stakes.
SDT (Ryan & Deci): autonomy + competence + relatedness drive motivation.	You choose problem order; the progress canvas (below) makes competence visible; "phone-a-friend" prompts supply relatedness.
No external rewards on struggle (Murayama & Kuhbandner, 2011) — they don't add to intrinsic curiosity.	No points. No badges. Only the resolution of the mystery and visible competence.

The one thing that IS allowed to be memorized (~5% of study time): the tiny core of platform constants — governor limit numbers, cron format, order of execution sequence. You'll still acquire them mostly through incidents; the flashcards are just for the residual 5%.

2. The module protocol (repeat for every topic)

Each module ≈ 90 minutes (or split into 2 sessions of ~45 min).

M0 — The Map (5–10 min)

Read the one-screen conceptual map. It's a bridge, not a preview: it tells you why this topic exists inside the platform's design, and what "knowing it" looks like at the end.

M1 — The Incident (30–45 min, hard cap)

Read the incident brief (story, symptoms, timeline, what the developer tried).
In writing, produce:
1. Your diagnosis hypotheses (≥2),
2. Your attempted fix (pseudocode / SOQL sketch),
3. A second, different approach (even an obviously bad one — generated-solution count predicts learning).
Rules: closed-book (no docs except platform basics), hard 45-min cap, hint ladder below.
Set your expectation now: you will probably not fully solve it. Producing your attempts IS the deliverable.

Hint ladder (write it down, keep it sealed):

Hint 1 (after 15 min with no new ideas): opens the "avenue" — the direction to think in.
Hint 2 (after 25 min stuck): opens the mechanism — the specific concept.
Hint 3 (only if you're about to quit or at 40 min): basically the answer's skeleton.

Stopping rules:

If you produced ≥2 attempts with at least one plausible-but-wrong → you've done the job. End early, reveal.
If 20 min pass with zero new ideas → take Hint 2 (not Hint 1).
If 35 min pass without any plausible attempt → the problem was too hard for your current schema — switch to "worked-example mode" (study the reveal as an example, then redo). Note the topic as needs example-first for next time.

M2 — The Reveal (15–25 min)

Read the postmortem: what actually happened, root cause, and explicit contrast with the attempts people (including you) typically make.
Redo the problem — compressed version, from memory, producing the correct approach. Close the loop immediately.

M3 — Retrieval Drill (15–20 min)

Closed-book, short-answer (never multiple choice). Write, then check against the answers.
If you can't answer → re-read the reveal, redo, and schedule a 1-day retest.

M4 — Interleaved Review (15–20 min)

Problem sets that mix THIS module with PREVIOUS modules. The choice of technique before solving is the learning event.

M5 — Close (5 min)

Log: "What I generated / where I failed / what I can now do that I couldn't before."
Fill in the Progress Canvas below.
Pick the next incident (autonomy).

3. The curriculum map (10 modules)

#	Topic	Weight in interviews	Status
1	Apex, Triggers, SOQL & Governor Limits	40–50%	✅ This module
2	LWC / UI / JavaScript	20–25%	✅ This module
3	Integrations & Async Apex	25–40%	✅ This module
4	Flows & Declarative Automation	15–20%	✅ This module
5	Security & Sharing Model	10–15%	✅ This module
6	Testing & Test Classes	8–12%	✅ This module
7	Deployment / DevOps / SFDX / CI-CD	8–12%	pending
8	Data Model & Relationships	5–10%	pending
9	Admin Basics for Developers	5–10%	pending
10	The Interview Itself (process, STAR, salary, behavioral)	—	pending

Recommended order: 1 → 3 → 2 → 4 → 5 → 6 → 8 → 7 → 9 → 10. (1, 3, 2 are the 75% — do them first. 5 and 6 lean on 1. 10 should be the last week before real interviews.)

4. Progress Canvas (fill after every module)

Module	Date done	My best "aha"	Where I failed	Can now do (in 1 sentence)	1-day ✓	1-week ✓	1-month ✓
1
2
3
4
5
6
7
8
9
10

5. Daily rhythm (30 min, every day, in parallel with modules)

5 rapid-fire trick questions (from Module 10's bank — they'll be distributed with each module).
1 retrieval question from any previous module (closed-book, written).
Recite the governor limits + order of execution one-liner (from Module 1's cheat sheets) — this is the allowed 5% memorization.
Explain yesterday's incident to an imaginary junior (the "phone-a-friend" prompt — this is your relatedness and your consolidation).

6. The one-sentence operating principle

"Never read the answer until you have written your own — even if your own is wrong. Then compare them like an investigator compares a suspect's story to the evidence."

Learning science sources: Kapur (2014, Cognitive Science), Kapur & Bielaczyc (2012), Loibl/Roll/Rummel (2017), Kirschner/Sweller/Clark (2006), Hmelo-Silver et al. (2007), Bjork (1994), Roediger & Karpicke (2006), Rowland (2014), Adesope et al. (2017), Cepeda et al. (2006/2008), Rohrer & Taylor (2007), Dunlosky et al. (2013), Ausubel (1960), Mayer (1979), Kalyuga et al. (2001), Sweller (1988), Loewenstein (1994), Kang et al. (2009), Gruber et al. (2014), Murayama & Kuhbandner (2011), Ryan & Deci (SDT), Slamecka & Graf (1978). Full URLs in the research appendix.

00 — How This Curriculum Works (Read This First — 10 Minutes)