Skip to main content
DevScallix

Roadmaps · L1

Junior Java Developer

A junior Java developer already knows the syntax and can solve small tasks. The goal at this level is to write correct, readable and verifiable code, and to learn how to work with a team on a real codebase.

← Roadmaps

How it differs from the previous level

Someone who has finished tutorials repeats the given steps and stops when the code runs. A junior developer can explain why the code works, investigates failures on their own, hands work over with tests and a Pull Request, and learns from review comments.

Expected knowledge

  • Java fundamentals: types, OOP, interfaces, records, immutability and the equals/hashCode contract
  • Collections: choosing between List, Set and Map and knowing their complexity
  • Using exceptions properly: checked vs unchecked, wrapping with a cause
  • Readable use of the Stream API and its limits
  • SQL: SELECT, JOIN, GROUP BY, INSERT/UPDATE, primary and foreign keys, the idea of an index
  • Spring Boot basics: controller, service and repository layers and dependency injection
  • REST: HTTP methods, status codes, JSON, simple validation
  • Git and the Pull Request flow: branches, commits, merge conflicts, review

Practical skills

  • Build a small REST service from scratch backed by PostgreSQL
  • Write unit tests with JUnit and mock simple dependencies
  • Locate the cause of a failure from a stack trace and logs
  • Step through execution with a debugger
  • Give variables, methods and classes meaningful names
  • Prepare a small single-purpose Pull Request and respond to review comments

Common mistakes

  • Using a mutable object as a HashMap key and not keeping equals/hashCode consistent
  • Catching an exception and silently leaving the catch block empty
  • Returning a JPA entity directly as the API response
  • Putting all the logic inside the controller
  • Replacing a test with a manual check that it seems to work

Learning priorities

  1. 1Solidify Java and OOP fundamentalsCollections, exceptions, equals/hashCode and immutability. Every later level builds on them.
  2. 2Learn SQL seriouslyJOINs, aggregation and the idea of an index. A large part of backend work is about data.
  3. 3Separate layers in Spring BootKeep controller, service and repository responsibilities apart, use DTOs and add validation.
  4. 4Make writing tests a habitAt least one unit test for every new piece of logic. See tests as a tool that checks your design.
  5. 5Be comfortable with Git, Pull Requests and DockerSmall commits, a clear PR description and a local environment started with docker compose.

Architecture maturity

A junior is not expected to design system architecture. It is important, though, to understand how code is split into layers, which way dependencies point and why business logic lives in the service rather than the controller. Adding code that fits the existing structure, and asking a question when something does not fit, is enough.

Example questions

  • Why must equals and hashCode be overridden together?
  • When would you pick ArrayList over LinkedList?
  • What is the difference between checked and unchecked exceptions?
  • How does the result of an INNER JOIN differ from a LEFT JOIN?
  • What problem does dependency injection solve in Spring?
  • Why should a Pull Request be kept small?

Exercises you can do on your own

  • Build a CRUD REST API for Order with controller, service, repository and DTOs kept separate.
  • Write three SQL queries on the same data using a JOIN, GROUP BY and a subquery. Read the EXPLAIN output.
  • Write a test that reproduces a lost element in a HashMap with a mutable key, then fix it with a record.
  • Start your project with one command using a Dockerfile and docker compose.

Articles for this level

Programs that fit

How close are you to this level?

The skills assessment builds a personal gap report from your answers. It is a recommendation, not a certificate.

Start the skills assessmentBuild your path to architect