Roadmap
Java Fundamentals → Production-Ready Senior Engineer
The whole route, 41 phases and 561 topics, from “what is a program” to defending a design. 448 of those topics are written; 56 are outlined and 57 have not been started. Nothing here is hidden — a course you cannot read yet is still on the map, because the map is what tells you how far it goes.
writtenoutlinednot started448 of 561 topics · 41 phases · ~187h
Before Java
Programming, the tools, and the platform installed.
33/33 topics · ~11h- 01Programming and developer foundationsWhat a program is, what runs it, and the tools you need before Java makes sense. A learner who already codes can skim this; one who cannot will fail Phase 3 without it.
- 02Java, installed and runningThe platform, the tools that come with it, and a first program you compiled yourself rather than clicked Run on.
The language
Syntax through generics — everything the JVM runs.
132/141 topics · ~48h- 03The Java languageSyntax, types, operators and control flow — taught against what the JVM actually does with each, because that is what makes the surprises stop being surprises.
- 04Methods and the execution modelHow a call works, what a frame holds, and why overload resolution surprises people. The phase where the call stack stops being a metaphor.
- 05Object-oriented programmingNot the four pillars recited — what each one buys, what it costs, and when composition is the better answer.
- 06The language, deeperModifiers, nested types, enums and annotations — the parts of the language that carry meaning a reviewer reads.
- 07Strings and arraysThe two types every program touches, and the memory each one actually costs.
- 08Exception handlingWhat an exception is to the JVM, which ones to declare, and how to design failure for a service rather than for a tutorial.
- 09The collections frameworkThe interfaces, the implementations, and the internals — because choosing a collection is a performance decision made at design time.
- 10GenericsType parameters, the erasure underneath them, and the wildcards that make an API usable.
Modern Java
Java 8's functional turn, and every release since.
62/69 topics · ~22h- 11Java 8 — the release that changed the languageLambdas, streams, Optional and java.time. The baseline of everything modern, and where the course's Java 8 anchor pays off.
- 12Modern Java, release by releaseWhat each release after 8 added, what problem it solved, and which of them are generally available rather than preview. Layered on the baseline rather than replacing it.
- 13Functional Java, properlyBeyond lambdas: what composition, purity and laziness buy, and where the functional style stops paying.
- 14I/O and filesStreams, channels and the NIO API — and how to process a file larger than memory.
- 15Reflection, annotations and class loadingHow frameworks do what they do — and the cost of each trick.
The machine
The JVM, its collectors, its threads, and measuring them.
59/61 topics · ~21h- 16JVM internalsThe machine your code runs on: its memory areas, its execution engine, and the bytecode in between.
- 17Garbage collectionHow the JVM reclaims memory, which collector to choose, and what a pause actually costs you.
- 18Concurrency and multithreadingFrom what a thread is to why your counter is wrong — and the memory model that explains both.
- 19Performance and troubleshootingMeasuring instead of guessing: profilers, flight recorder, and the handful of failure shapes that cover most incidents.
Building services
Data, Spring, and an API that survives its clients.
57/67 topics · ~23h- 20SQL and JDBCThe database is where most backend latency lives. SQL that uses an index, and JDBC that does not leak connections.
- 21Build toolsMaven and Gradle as dependency resolvers first, build runners second.
- 22SpringThe container, the proxies, and the two or three mechanisms that explain most of Spring's magic.
- 23JPA and HibernateThe persistence context, and every surprise that follows from not knowing it is there.
- 24REST API engineeringAn API is a contract you cannot take back. Designing one that survives its clients.
Shipping and systems
Getting it out, proving it works, and everything it talks to.
58/91 topics · ~29h- 25DevOps for Java engineersEnough Git, Docker, CI and Kubernetes to own your service from commit to running process.
- 26TestingTests that fail for the right reason, at the right level, fast enough to run.
- 27SecurityAuthentication, authorisation, and the vulnerabilities a backend engineer is personally responsible for.
- 28Messaging and event-driven architectureKafka as a system rather than an API — partitions, groups, offsets, and what each delivery guarantee really promises.
- 29MicroservicesBoundaries first. Then the failure modes that distribution hands you for free.
- 30Distributed systemsThe theory you need to argue about a design: what you can have, what you must give up, and what fails.
- 31CachingThe fastest query is the one you did not make — and the hardest bug is the stale answer.
- 32ObservabilityLogs, metrics and traces — and the discipline of being able to answer a question you did not anticipate.
- 33CloudThe concepts, taught once, with AWS as the worked example and the equivalents named.
Senior work
Design, architecture, incidents, and the projects that prove it.
47/99 topics · ~33h- 34SOLID, clean code and refactoringPrinciples as decisions with costs, not commandments.
- 35Design patternsEach pattern as the answer to a problem — with its Java form, where Spring already uses it, and when it is the wrong tool.
- 36Architecture and domain modellingLayers, ports and adapters, and a domain model that survives its first change of framework.
- 37System designA method, the components, and enough worked designs that the method becomes a habit.
- 38Production engineeringOwning a service: what you promise, how you know it is broken, and what you do at 3am.
- 39Data structures and algorithms, in JavaEnough to pass an interview and, more usefully, to know which collection you are really choosing.
- 40Interview masteryThe same material, rehearsed the way it is actually asked — by level.
- 41ProjectsEach project adds one thing the last did not have. The capstone is the last one.
Course order
The 35 courses, in prerequisite order
9 stages. The order is the prerequisite graph, not an opinion: a course appears once everything it builds on is behind it. Locked means suggested later, never closed. 208 lessons are written today.
Completed Current Available Locked (advisory)
Start
Foundations
Language depth
Framework
Data & APIs
Distribution
Operate
Design & lead
Stage 9
End
Production-Ready Senior Java Backend Engineer35 courses. Then the interview set, the projects, and the incidents.
Select a course to see what it covers, what it needs and where it leads.