Java Backend Career Track: Full syllabus — 24 weeks
Six phases from first program to a defended backend project. Every week has a concrete lab and a practice assignment, and most assignments are submitted as a Pull Request.
This is the planned syllabus for the founding cohort. The order and depth may be adjusted before and during the cohort based on the group's level. Weekly hours and the schedule are announced with the cohort.
01 · Weeks 1–4
Foundations
Phase goal: Write and debug small Java programs and use Git.
Week 1
How programs run
- JDK, JVM and the IDE
- Compiling and running a program
- Variables, types and operators
- Reading compiler errors
- First Git commits
Lab: Set up the JDK, IntelliJ IDEA and Git, then build a small console calculator and commit it in several meaningful steps.
Assignment: A unit converter (for example temperature and length) with a clean commit history, pushed to a GitHub repository.
Week 2
Control flow, methods and debugging
- Conditions and loops
- Methods and parameters
- Debugging with breakpoints
- Decomposing a problem into steps
Lab: Build a number-guessing game, splitting it into small methods and finding a planted bug with the debugger.
Assignment: A text-based menu program (for example a simple expense tracker in memory), with a short note on how you broke the problem into steps.
Week 3
Arrays, strings and simple algorithms
- Arrays and strings
- Linear and binary search
- Sorting intuition
- Thinking about cost (Big-O intuition)
Lab: Implement search and a simple sort by hand, then compare how many steps each needs on growing inputs.
Assignment: A word-statistics tool for a text (word count, most frequent words) and a written comparison of two approaches.
Week 4
OOP I and the first Pull Request
- Classes and objects
- Encapsulation
- Constructors
- Git branches
- Your first Pull Request
Lab: Model a small domain (for example a bank account or a library book) as classes and submit it on a feature branch as a Pull Request.
Assignment: Rework the console application from the phase using classes, submit it as a Pull Request and address the review comments.
Checkpoint: A console application submitted as a Pull Request, reviewed, and improved after feedback.
02 · Weeks 5–9
Java Core
Phase goal: Model a domain with clean, tested Java.
Week 5
OOP II and the first SOLID principles
- Interfaces and polymorphism
- Inheritance versus composition
- Single responsibility and open/closed
- Designing for change
Lab: Refactor a small notification or payment example from inheritance to interfaces and composition.
Assignment: Design a small domain (for example order pricing with several discount rules) behind interfaces, submitted as a Pull Request.
Week 6
Collections and generics
- List, Set, Map and Deque
- Choosing a collection by access pattern
- Generics and type safety
- Iteration and sorting with Comparator
Lab: Solve the same task (for example a lookup of orders by customer) with different collections and explain which fits best.
Assignment: An in-memory catalog with search, grouping and sorting, with a short note on why you picked each collection.
Week 7
Exceptions, equality, records and enums
- Checked and unchecked exceptions
- equals and hashCode
- Records and enums
- Immutability
- Designing error handling
Lab: Replace error codes in an earlier project with meaningful exceptions and turn value objects into records.
Assignment: Add validation and custom exceptions to your domain model, with immutable value objects, as a Pull Request.
Week 8
Lambdas, streams and clean code
- Lambdas and functional interfaces
- Streams: map, filter, collect
- Optional
- Naming and small functions
- Readable conditionals
Lab: Rewrite loop-heavy code with streams where it helps readability, and refactor one long method into small named ones.
Assignment: A reporting feature on your domain (for example totals per customer) using streams, with a self-review of readability.
Week 9
Testing, Maven and concurrency basics
- Unit tests with JUnit 5 and AssertJ
- Maven build and dependencies (and what Gradle does differently)
- Test design: arrange, act, assert
- Threads and ExecutorService
- Why shared state is hard
Lab: Move the domain project to Maven, write unit tests for its core rules, and run a small task with an ExecutorService.
Assignment: Raise test coverage of your domain on meaningful behaviour, and demonstrate a race condition and one way to fix it.
Checkpoint: A tested domain library (for example a library or order domain), code review and a short defense of design decisions.
03 · Weeks 10–12
Data
Phase goal: Design and query a relational model and use it from Java.
Week 10
SQL fundamentals with PostgreSQL
- PostgreSQL in Docker
- SELECT and filtering
- Joins
- Aggregation and grouping
Lab: Start PostgreSQL in Docker, load a small sample dataset and answer a list of business questions with queries.
Assignment: A set of SQL queries over a provided schema, each with a one-line explanation, submitted as a Pull Request.
Week 11
Data modelling and transactions
- Primary and foreign keys
- Normalisation
- Constraints
- First indexes and reading a query plan
- Transactions and ACID
Lab: Design the schema for an order domain, add constraints and an index, and compare a query plan before and after.
Assignment: An ER diagram and a SQL schema for your own small domain, plus a note on which constraints protect which rules.
Week 12
From JDBC to JPA/Hibernate
- JDBC basics
- Entities and relationships
- Repositories
- The N+1 problem
- Flyway migrations
Lab: Read data with plain JDBC first, then map it with JPA, provoke an N+1 query and fix it.
Assignment: Persist your domain with JPA and Flyway migrations, as a Pull Request that includes the migration scripts.
Checkpoint: A data-model review: ER diagram, migrations and queries explained.
04 · Weeks 13–17
Spring and REST APIs
Phase goal: Build a secured, validated, tested REST API.
Week 13
Spring Core
- Inversion of Control
- Dependency injection and beans
- Configuration and properties
- Profiles
Lab: Wire a small service by hand, then let Spring wire it, and switch behaviour between two profiles.
Assignment: A configurable component (for example a price calculator with environment-specific settings), submitted as a Pull Request.
Week 14
Spring Boot REST
- Controllers and DTOs
- HTTP methods and semantics
- Resource design and status codes
- Pagination and filtering
- Using an HTTP client
Lab: Expose your domain as a REST API with create, read, update and delete, and exercise it with an HTTP client.
Assignment: Design and implement the endpoints for one resource with proper status codes and pagination, with a short API design note.
Week 15
Validation, errors and the service layer
- Bean Validation
- Consistent error responses (Problem Details)
- Service layer
- @Transactional and its boundaries
Lab: Add validation and a global exception handler that returns Problem Details, and move business rules into a service.
Assignment: Make the API reject invalid input consistently and keep each business operation in one transaction, as a Pull Request.
Week 16
Spring Security
- Authentication and authorization
- Password hashing
- Roles and protected endpoints
- Sessions versus JWT (basic level)
- Common mistakes to avoid
Lab: Add registration and login, hash passwords, and protect endpoints by role.
Assignment: Secure your API so users see only what they are allowed to, with a short threat note listing what the design does not cover.
Week 17
Testing Spring applications and API docs
- Slice tests
- Integration tests with Testcontainers
- Mocking with Mockito where it fits
- OpenAPI documentation
Lab: Write a controller slice test and a repository integration test against PostgreSQL in Testcontainers, and generate the OpenAPI document.
Assignment: Cover the main flows of your API with tests and publish its OpenAPI description, as a Pull Request.
Checkpoint: The secured REST API reviewed as Pull Requests and defended.
05 · Weeks 18–21
Delivery and systems
Phase goal: Run the service the way a team would and understand the next layer of systems.
Week 18
Docker and configuration
- Images and containers
- A Dockerfile for the API
- docker compose for API plus database
- Configuration and secrets basics
Lab: Containerise your API and start it together with PostgreSQL using docker compose, with configuration from the environment.
Assignment: A reproducible local setup: one command starts the API and database, documented in the README, submitted as a Pull Request.
Week 19
CI/CD and observability basics
- A pipeline that builds, tests and packages
- GitHub Actions
- Structured logs
- Health checks and metrics with Actuator
- Reading logs to find a problem
Lab: Create a GitHub Actions workflow that builds and tests the project and builds the image, and expose health and metrics endpoints.
Assignment: Add the pipeline and Actuator endpoints to your project and fix a deliberately broken build, as a Pull Request.
Week 20
Redis, messaging and Kafka fundamentals
- Caching with Redis and TTL
- What not to cache
- Why asynchronous messaging
- Kafka topics, producers and consumers
- One hands-on exercise per tool
Lab: Cache one read-heavy endpoint in Redis, then publish an event to Kafka locally and consume it in a second small application.
Assignment: A short write-up on where caching and messaging would and would not help your project, plus the working exercises.
Week 21
Microservices and cloud fundamentals
- Service boundaries
- When not to split a system
- Regions and managed databases
- Running a container in the cloud
Lab: Sketch how your project could be split, argue against splitting it, and walk through running its container in a cloud environment.
Assignment: A one-page architecture note comparing a single application with a split design for your project, with your recommendation.
Checkpoint: A running system demo (API, database, container and pipeline) with a short walkthrough.
06 · Weeks 22–24
Capstone and career
Phase goal: Deliver and defend a complete backend project and prepare for interviews.
Week 22
Capstone planning and first increments
- Requirements
- Domain model
- API design
- Decision records (ADRs)
- Building in Pull Requests
Lab: Write the requirements, domain model and API outline for your capstone, record key decisions as ADRs and open the first Pull Requests.
Assignment: A planned and reviewed capstone backlog, with the first working vertical slice merged.
Week 23
Capstone build, review and interview preparation
- Building and reviewing in Pull Requests
- Java, SQL and Spring interview questions
- Explaining your own project
- Reviewing a peer's code
Lab: Finish the core features with tests and a pipeline, and rehearse explaining one design decision aloud.
Assignment: A stable capstone branch with README, tests and pipeline, plus written answers to a set of technical questions.
Week 24
Final practical evaluation
- Capstone defense
- Live code-review exercise
- Interview simulation
- A personal next-step plan
Lab: Present and demonstrate the capstone, review unfamiliar code live and take part in a mock technical interview.
Assignment: A personal next-step plan: strengths, gaps and what to practise next, based on the evaluation feedback.
Checkpoint: The final practical evaluation.
How learning is assessed
- Weekly Pull Request reviews with written feedback on naming, structure, tests and design.
- A checkpoint at the end of each phase, with a short defense of your decisions.
- Practical tasks over memorisation: you are assessed on code you wrote and can explain.
- A final practical evaluation covering the capstone, a live code review and an interview simulation.
- Feedback is a recommendation for your next steps; the outcome depends on your own work and consistency.
- No program can guarantee employment, and this one does not.
Tools you will use
- JDK 21
- IntelliJ IDEA
- Git and GitHub
- Maven (with a Gradle overview)
- JUnit 5
- AssertJ
- Mockito
- PostgreSQL
- Flyway
- Spring Boot 3
- Spring Security
- Testcontainers
- Docker and docker compose
- An HTTP client (for example Postman or the IntelliJ HTTP Client)
- GitHub Actions
- Redis
- Kafka (local)
Workload
Weekly hours and the schedule are announced with the cohort. Besides the live sessions, plan regular independent practice every week: the labs and assignments are where most of the learning happens.