Pre-Mortem 02 — Topic Skipping

Failure Mode: Skipping foundational phases, racing ahead to “the interesting stuff.”
Probability: MEDIUM-HIGH — 60%
Peak Risk Period: M1–M2. The damage is invisible until M4–M5 when you try to build on missing foundations.

Why the Probability Is This High For You Specifically

You are smart and impatient. These are not insults — they are accurate observations about the learner profile that leads to this specific failure mode. Smart people feel the pull to skip past things that seem obvious. “I already kind of know Big-O — I’ve seen it before.” That sentence has preceded the downfall of hundreds of competent engineers in this exact learning arc.

The problem with “already kind of knowing” something is that “kind of” means your model has the shape of the concept but not the precision. In foundations, imprecision is debt. It shows up in Phase 3 when you can’t prove why Dijkstra fails on negative weights. It shows up in Phase 4 when you can’t analyze whether your graph algorithm is O(V log V) or O(V²). It shows up in competitive programming when you choose the wrong data structure for a problem and lose the race to 200ms by 40ms because you made an assumption you never verified.

The foundation is not boring prerequisite material. It is the calibration of your reasoning instrument.

What It Looks Like

Month 1: Phase 0 (Big-O foundations, arrays, hashing). You read the Big-O material, feel like you mostly know it, do a few easy problems, call it done. You move to Phase 1 early because “trees are more interesting.”

Month 3: You’re in Phase 2 (Trees and Recursion). You can implement an inorder traversal but you can’t prove its time complexity from scratch — you just know “it’s O(n).” When the problem requires proving why a modified traversal is O(n log n) instead of O(n), you make an assumption that happens to be wrong.

Month 5: You’re in Phase 4 (Graphs). You fail to recognize that a certain graph representation has O(V²) space complexity rather than O(V+E), because you never rigorously internalized the adjacency list vs. adjacency matrix tradeoff. You debug the wrong thing for an hour.

Month 6-7: DP problems require reasoning about state space size. Because your Big-O foundations have holes, you can’t systematically estimate whether a DP table will fit in memory or whether your transition function is truly O(1) per state. You guess. Sometimes you’re right. Sometimes you’re not.

Early Warning Signals

  • You’re solving problems in Phase N but cannot state the time complexity of your solutions from first principles (not from memory)

  • You say “it should be fast enough” about a solution without measuring or proving it

  • You advanced a phase before completing at least 80% of its associated problem set

  • You failed the exit criteria assessment for the current phase but advanced anyway

  • You’re doing Phase 2 work while having Phase 1 problems you “couldn’t solve” sitting unresolved in your notebook

Concrete Mitigation

Rule 1: Sprint exit criteria are non-negotiable.

Every phase has exit criteria (documented in the phase roadmap). You must pass your own exit assessment before advancing. If you have not met the criteria, you extend the phase by one sprint. There is no timeline pressure that overrides this — the 9-month plan has buffer built in specifically for this.

Rule 2: Write and take your own exit exam.

Before advancing any phase, write 3 questions that test the core concepts of that phase. Answer them from scratch — no notes, no AI, no references. If you can answer all 3 correctly, you’ve passed. If you can’t, you haven’t mastered the phase yet.

Example for Phase 0:

  1. Prove that the following function is O(n log n), showing your work: [insert a nested loop problem]

  2. What is the space complexity of a recursive depth-first search on a binary tree with n nodes?

  3. Given an array of n integers with possible duplicates, describe an O(n) approach to find all duplicates.

If you can’t answer these without help, you’re not ready for Phase 1 regardless of how long you’ve spent in Phase 0.

Rule 3: Record complexity in every solution.

For every problem you solve, record: time complexity, space complexity, and one sentence justifying each. This makes foundation knowledge visible in every session.

Escalation Trigger

You’ve advanced a phase but cannot solve a medium-difficulty problem from that phase in under 30 minutes:

Go back one phase for one sprint. Specifically: identify which foundational concept the failed medium problem required, and spend the sprint reinforcing that concept with targeted problems. Do not treat this as failure — treat it as accurate diagnosis.

The Meta-Point

The foundations are not the boring warm-up before the real learning. They are the real learning. Every advanced topic in DSA — DP, segment trees, flow algorithms — is foundations applied recursively. A crack in the foundation does not stay in the foundation; it propagates upward through every structure you build on top of it.

Phase 0 and Phase 1 done with full rigor will save you 3x the time in Phase 4 and Phase 5. This is not motivational framing — it is mechanical truth about how layered knowledge structures work.