Become a Production-ReadyJava Backend Engineer
- Learn
- Practice
- Build
- Master
One curriculum from the JVM to distributed systems, taught the way the job is done: real code, real failure modes, and the question an interviewer actually asks. 35 courses, labs that execute, projects, system design and senior-level interview preparation.
41 phases, 561 topics, one route
From what a program is, to a distributed system you can defend in a review. 448 topics are written; 56 are outlined and 57 are not started. We show all of it — a syllabus that hides its gaps is not a syllabus.
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.
From your first class file to a system you can defend
9 stages, 35 courses, in the order the prerequisites demand. Nothing is locked; the order is a recommendation you can see the reasons for.
The whole stack a senior is expected to own
The language, properly: types, objects, collections, generics, and everything Java 8 through 25 added.
Concurrency you can reason about, and a JVM you can read: memory model, garbage collection, class loading, profiling.
Spring Core, Boot, Data JPA and Security — the framework as it is used in production, not as it is demoed.
REST that survives contact with clients: design, validation, errors, pagination, versioning, idempotency, rate limits.
Relational databases in depth, then MongoDB, Redis and search — indexes, transactions, isolation, locking, replication.
Service boundaries, discovery, gateways, resilience, and the data problems distribution creates: sagas, outbox, CQRS.
Kafka as a system: partitions, consumer groups, rebalancing, offsets, retries, dead letters, schema evolution, exactly-once.
Git, Maven and Gradle, Docker, Kubernetes, CI/CD, Linux, Nginx, and AWS — the path from a commit to a running service.
JUnit 5, Mockito, Testcontainers, contract and performance testing — tests that catch the bugs that ship.
Logs, metrics, traces, and the discipline of diagnosing a live system: incidents, RCA, memory leaks, slow queries.
Authentication, authorization, JWT, OAuth2, OWASP, secrets — the parts a backend engineer is personally responsible for.
High-level design, low-level design and distributed systems: capacity, trade-offs, failure handling, and how to argue them.
Reading is the start. The rest is doing.
Labs that run
Java, SQL, Spring MVC, Kafka and Redis problems with real tests. The SQL lab runs in your browser; the Java labs on a sandboxed runner that re-checks every pass.
Open the practice hub →Production debugging
Incidents with dashboards, logs and a timeline. You diagnose — OOMs, consumer lag, pool exhaustion, deadlocks — and then compare with the write-up.
Debug an incident →Projects worth defending
Six backend systems with milestones, acceptance criteria and the trade-offs you will be asked about. Build them the way a team would.
See the projects →System design, argued
Every estimate states its assumptions, every decision states its cost. Design it first, then compare with the brief.
Design a system →