F4 — Framework Worship

Probability without countermeasures: 40%. Window: M4-M8, with peak risk in M5-M6. Severity if unchecked: medium-high — you build Spring apps that break in ways you cannot debug, because you skipped the JVM layer underneath.

What This Failure Mode Actually Is

You are in M5. Phase 03 (OOP refactoring) is going okay but feels slow. You watch a Spring Boot tutorial on YouTube “just to see what it looks like.” Twenty minutes later you are three tabs deep into @RestController examples. You think: this is what real Java engineers actually write. This is where the jobs are. Why am I spending another month on a BankAccount class hierarchy when I could be shipping a REST API?

You start a Spring Boot side-project. It works — Spring makes it easy. You have endpoints, JSON responses, a Postgres connection. You feel productive. You post a screenshot on LinkedIn. It gets 40 likes.

Then something breaks. A request hangs. A connection pool exhausts. A transaction rolls back and you do not know why. You cannot debug it because you do not know what Spring is doing underneath — you never learned the JVM, the threading model, the classloader, the JDBC driver behavior. Spring hid all of it from you, and now you are stuck.

You have skipped the layer where senior Java engineers actually live.

Why the Probability Is 40%

Lower than F1/F2/F3, but real. Three forces:

  1. Spring feels like adulthood. Writing a LinkedList in M2 felt childish. Spring feels like “real Java.” The signal is misleading — every senior engineer knows the LinkedList matters more.

  2. Job listings mention Spring, not JVM internals. You will read 40 job descriptions in M6 and 39 will say “Spring Boot experience required.” Zero will say “must understand JIT compilation.” This creates false urgency.

  3. AI agents make Spring trivial. With Cursor, you can scaffold a Spring app in an hour that would have taken 3 days in 2018. This is precisely the trap — the agent hides the parts you need to learn.

The 40% is calibrated for engineers who came from ML/Python and see Spring as the “real Java” they need to catch up on. It is real Java. But it is not first Java.

Early Warning Signs

  • You are watching Spring tutorials during Phase 03 or Phase 04 hours.

  • Your browser history has more Baeldung Spring pages than JDK Javadoc pages.

  • You started a Spring project before M8.

  • You cannot answer: “what happens between main() returning and the JVM process exiting?” — but you can annotate a controller with 6 different Spring annotations.

  • You say the phrase “Spring handles that for you” more than once a week.

  • You are excited about @Transactional but you have never written a synchronized block by hand.

  • You added spring-boot-starter-* to your LATER.md five times and it keeps pulling you back.

Root Causes

  1. Framework mastery is legible; runtime mastery is invisible. You can show a Spring app on your resume. You cannot show “I understand tiered compilation” — even though the second is worth more.

  2. The framework promises productivity. And it delivers — for the first 100 lines. Then it demands the exact knowledge it seemed to save you from.

  3. Peer pressure and job-listing anxiety. M6 is when you start looking at job descriptions and panicking. Framework worship is the panic response.

  4. Ambiguity aversion (echoes of F1). JVM internals are ambiguous, hard, and non-linear. Frameworks feel deterministic. Your brain prefers deterministic.

The Governing Rule

JVM internals before Spring internals. No exceptions. This is not preference — this is the ordering that makes the difference between an engineer who can debug production Java and one who files a ticket to the “platform team.”

Specifically:

  • Phase 04 (concurrency) BEFORE any Spring work. You must understand synchronized, volatile, the java.util.concurrent primitives, and the Java Memory Model by feel.

  • Phase 05 (JVM internals: classloaders, GC, JIT, tiered compilation) BEFORE any Spring work.

  • Phase 06 (I/O, NIO, networking) BEFORE any Spring work.

  • Phase 07 (Spring) is where Spring starts. Not before.

Mitigation

The Browser Blocklist (M1-M7)

Add these to a browser blocklist until end of M7:

  • spring.io/guides/*

  • docs.spring.io/*

  • baeldung.com/spring-*

  • YouTube channels: “Java Brains Spring”, “Amigoscode Spring Boot”, “Marco Codes Spring”.

You can unblock them the moment you start Sprint 15 (Phase 07). Not one day before.

The Curiosity Log

You will have Spring curiosity in M4-M6. That is normal — Spring is genuinely interesting. Do not suppress the curiosity; defer it.

Keep a SPRING_CURIOSITY.md file in your notes. When you have a Spring question, write it there with the date. Do not open a tab. Do not watch a video. Just log it.

When M8 starts, that file becomes your Phase 07 syllabus. You will find that many of the questions from M4-M6 answer themselves once you have the JVM foundation. That is the point.

The “Would I Trust This In Production” Test

Before you write any Spring code in Phase 07, ask of every annotation and framework feature:

“If this breaks in production at 2am, would I know what is happening under the hood?”

If the answer is no, you go read the source or the JEP or the JVM behavior first. Frameworks are only as trustworthy as your understanding of what they hide.

The Vanilla-First Rule (Phase 07)

When Phase 07 starts, your first Spring project is not a Spring project. It is a vanilla Java servlet application — no framework, just a HttpServer and hand-wired routing. You write it, ship it, and then rewrite the same thing in Spring Boot. The delta between the two versions IS the Spring learning. That is when frameworks stop being magic.

Escalation Trigger

If you find yourself with a Spring project committed before end of M7, you back it out:

  1. Freeze the repo, do not delete it (you will use it as the “before” version in Phase 07).

  2. Return to whatever phase you skipped. Do not resume Spring until that phase is complete.

  3. Write a retro entry in your LAB.md titled “Why I jumped to Spring early and what I missed.” This is not shame — this is calibration. You will refer to it in Phase 07.

What Success Looks Like

By end of M7 (before Phase 07 begins):

  • You can explain classloader delegation without notes.

  • You know the difference between platform threads and virtual threads (Loom) and when each matters.

  • You have written at least one non-trivial concurrent program (bounded blocking queue, work-stealing thread pool, or similar) from scratch.

  • You know how to read a GC log.

  • You have not touched Spring.

By end of M8:

  • Spring feels less like magic and more like a well-designed set of conventions on top of things you understand.

  • You can predict, from the annotation, roughly what the framework will do at runtime. Sometimes you can even predict what will break.

That is a senior engineer relationship with a framework. You cannot get there by starting with the framework.

Previous: 03_fm_dsa_black_hole.md | Next: 05_fm_tutorial_hell.md