Spring Boot

Before any annotation makes sense, you need to know what problem it's solving. Spring wasn't the first way to write Java backends — it was a reaction to how painful the alternatives were.

This is the single idea everything else in Spring builds on. Get this genuinely clear and every annotation you meet later is just "a way of telling the container something," not new magic each time.

"Bean" gets thrown around from your first day with Spring. This module is precisely what one is, how it's born, and how it dies.

Four annotations do almost identical things mechanically, and picking the wrong one is a code-smell, not a bug. This module is why they're different, and how Boot decides what to wire up without you asking.

The last foundations piece before you build anything real: how Spring Boot gets its configuration, how that configuration changes per environment, and what a "starter" dependency actually bundles.

Foundations are done. This module is where an HTTP request actually becomes a method call in your code — and the request/response shapes real clients depend on.

Module 06 flagged the risk. This module is the fix, done properly, and the mapping code that comes with it.

"Just extend JpaRepository and you get CRUD for free" is true and also hides a lot. This module is what's actually running underneath that one line of interface declaration.

The module where JPA quietly punishes assumptions carried over from plain SQL. Get lazy vs. eager and the N+1 problem genuinely right here, because it's the most common real-world Spring Boot performance bug.

A REST API that returns a raw stack trace as a 500 response is unfinished. This module is how to make failure a first-class, designed part of your API contract.

Closing out the REST & Database arc: how to actually verify your API by hand, then how to run a real database locally without installing Postgres directly on your machine.

Before JWT, before roles — every secured request in Spring passes through the same mechanism. This module is that mechanism.

The single most requested Spring Boot topic, and the one most often implemented with a vague understanding of what's actually inside the token. This module fixes that.

Module 13 answered "who are you." This module is "what are you allowed to do" — and the two places in Spring Security you can actually enforce that answer.

Module 13's access token expires in 15 minutes on purpose. This module is what happens next, without forcing your user to log in again every quarter hour.

Module 10 built centralized exception handling for your business logic. Security exceptions are thrown from inside the filter chain — before your @ControllerAdvice even runs — so they need their own handling path.

Your REST API works and is secured. Now it needs to survive real traffic without hammering Postgres for the same query a thousand times a second.

Everything through Module 17 lived in one deployable application. This module is the decision to split it apart — and, honestly, why you often shouldn't rush into it.

Module 18 §4 flagged that a producer shouldn't have to block waiting for every interested service to finish reacting. This module is the mechanism that makes that possible.

Module 19 handled the fire-and-forget case. This module is for when a client genuinely needs a synchronous answer, and you have several services instead of one.

You now have several services, a database, Redis, and Kafka — all needing to run together. This module is how to stop starting each one manually, in the right order, by hand.

print("here") doesn't survive past your laptop. This module is how a real Spring Boot service tells you what it's doing once it's running somewhere you can't attach a debugger.

A single @Transactional annotation hides an entire proxy-based mechanism underneath. This module is what actually happens when you add it — and the specific ways it silently fails to do anything at all.

Some work doesn't happen in response to a request — it happens every night at 2am, or every 30 seconds, forever. This module is how Spring Boot runs code on a clock instead of on a request.

Not every piece of work needs to finish before you respond to the client. This module is how to kick off background work from inside a request without making the caller wait for it.

A profile picture or a PDF invoice has to get from a browser's file picker into your storage somehow. This module is that path, plus the validation gaps that turn an upload endpoint into a security hole.

"Is the service healthy?" is a question your infrastructure asks constantly, automatically. This module is the built-in feature that answers it, without you writing a single health-check line yourself.

@Transactional, @Async, and @PreAuthorize all secretly work the same way underneath. This module is that shared mechanism itself — and how to write your own cross-cutting behavior using it directly.

A slow endpoint is rarely slow for one obvious reason — it's usually three or four smaller ones stacked together. This module is how to find them systematically instead of guessing.

Every earlier module built or hardened one piece correctly in isolation. This module is the checklist for whether they're ALL actually turned on together before real users depend on this service.

Every module built or hardened one piece. Here's the whole system, fully assembled — an Order → Kafka → Inventory/Notification/Analytics architecture, secured, cached, gatewayed, and containerized.