Junior's Roadmap
Labels
🔴 (Advanced Junior) – Requires deeper knowledge - Advanced Juniors/ Mid-level developers
🟢 (Junior) – Fundamentals, should be known by any junior developer
Core Java Fundamentals 🟢
Object-Oriented Programming (OOP)
Encapsulation – Private fields, getters, setters
Inheritance – Superclass, subclass, extends
Polymorphism – Static (method overloading) vs Dynamic (method overriding)
Abstraction – Interfaces, abstract classes, partial vs complete abstraction
The Diamond Problem
Java Basics
Primitive types vs Wrapper classes
Strings & String Pool (what is and how does it work)
Immutable vs Mutable objects
Static keyword (fields, methods, blocks)
Access Modifiers
final keyword (class, method, variable)
Enums & Usage
equals() and hashCode() contract
Important Java 8 / 11 Features

Data Structures, Collections & Algorithms 🟢
What is a data structure?
Array vs. ArrayList vs. LinkedList (how do they actually work, how they are implemented)
Stack, Queue, PriorityQueue
Set (HashSet, LinkedHashSet, TreeSet)
Map (HashMap, LinkedHashMap, TreeMap)
HashTable vs HashMap
Hash function and Hashing techniques
Collisions in HashMap & how Java resolves them
Comparable vs Comparator
Iterable vs Iterator
Big O Notation – Alg. Complexity
Sorting Algorithms vs/and Searching Algorithms

Java Concurrency (Multithreading) 🔴
Thread Lifecycle
Thread vs Runnable (which one is preferred to be used)
synchronized keyword & Locks
Executors & Thread Pools
Deadlock, Livelock, Starvation
Atomic Variables (AtomicInteger, AtomicLong)

Functional Programming in Java 🟢
Lambda Expressions
Stream API (methods, usage, operations)
Intermediate vs Terminal Operations in Stream API
Functional Interfaces (Function, Predicate, Consumer, Supplier)
Optional Datatype & Avoiding NullPointerException

Design Patterns 🟢
Here I will list most used patterns, but you may know more than just these.
Categories in design patterns (Creational, Structural, Behavioral)
Singleton (Eager vs Lazy initialization)
Factory Method Pattern
Builder Pattern
Strategy Pattern
Observer Pattern
Useful link: https://refactoring.guru/design-patterns

Java Memory Model 🔴
Java Memory Model
Heap vs Stack
Garbage Collection (GC)
Strong, Weak, Soft, and Phantom References
OutOfMemoryError
Heap Space vs Metaspace

Spring & Spring Boot 🟢
Core Spring (IoC, DI, Beans)
Inversion of Control (IoC) & Dependency Injection (types of DI)
IoC container, IoC Container Implementation in Spring
ApplicationContext vs. BeanFactory
Stereotype annotations (@Component,
@Service
,
@Repository
,
@Controller
)
Bean (declaration, usage)
Bean Scopes (singleton, prototype, request, session)
@Autowired
 on Field vs. Constructor Injection
Spring Boot Basics
Spring Boot vs Spring Framework
Spring Boot Starter Packages (spring-boot-starter-web, spring-boot-starter-data-jpa)
Embedded Web Servers (Tomcat, Jetty, Undertow)
Auto-configuration & Properties (application.properties vs application.yml)
Schedulers and Caching
Layered Architecture (Presentation Layer, Service Layer, Data Access Layer)
Spring Boot Configuration
@Configuration
 and
@Bean

@Value
 usage
Externalized Configuration with application.properties
Spring Profiles (@ActiveProfiles, spring.profiles.active)

Spring MVC & RESTful APIs
MVC 🟢
Model-View-Controller Components
Spring MVC Flow (from sending the HTTP request to returning the response)
DispatcherServlet
Model-Attribute
Form Handling & Validation (BindingResult,
@Valid
, .hasErrors())
Session & Cookies
Interceptors
View Technology
View Resolver
Thymeleaf Integration
REST 🟢
What is REST?
What makes an API RESTful? (REST Constraints)
HTTP Methods
RESTful Endpoint Design Best Practices
HATEOAS
API Versioning (/v1/users vs. Accept-Version header)
Status Codes (200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Internal Server Error)
REST APIs with Spring 🟢
@RestController
,
@RequestMapping
,
@GetMapping
,
@PostMapping

Path Variables (@PathVariable) vs. Request Params (@RequestParam)
Request Body (@RequestBody)
Response Handling (ResponseEntity<T>)
Exception Handling with
@ExceptionHandler
 and
@ControllerAdvice

Swagger Documentation

Security 🟢
How does Spring Security work?
Stateless vs Stateful
SecurityFilterChain
Authentication vs Authorization
Principle (what & how to retrieve it in methods)
SecurityContext and Authentication object 🔴
Authentication provider vs Authentication manager 🔴
UserDetails vs Principle
UserDetailsService + PasswordEncoder
JWT - what & why (Header, Payload, Signature) (Stateless authentication) 🔴
What is JWT Secret? 🔴
How to implement JWT Authentication in Spring 🔴
Security Filters (OncePerRequestFilter)
Role-Based Access Control (@PreAuthorize,
@Secured
)

Database & JPA/Hibernate 🟢
ORM (Object-Relational Mapping)
ORM Implementation - Hibernate
JPA vs Hibernate
What is Entity?
@Entity
,
@Table
,
@Column
,
@Id
,
@GeneratedValue

Entity Relationships (@OneToOne,
@OneToMany
,
@ManyToMany
)
Cascade Types & Fetch Types
ACID
Transaction Management (@Transactional)
Isolation levels and propagation in transactions 🔴
Connection Pooling (HikariCP) 🔴
Database indexes (what is and why do we need them)
How to create column indexes in Hibernate

Aspect-Oriented Programing 🔴
AOP (what is and why do we need this)
Spring AOP
AOP Core concepts (Aspect, Advice, Pointcut)
Proxy Mechanisms (JDK Dynamic Proxies vs CGLIB Proxies)
Performance Impact of AOP
@Before
,
@After
,
@Around
 and other useful annotations

Microservices & Cloud 🔴
Monolith vs Microservices Architecture
Benefits of using Microservices
Data consistency problem across microservices: SAGA Pattern - THIS IS REALLY ADVANCED TOPIC FOR JUNIORS
Monolith -> Microservice migration strategies (Parallel runs, Strangler Pattern)
What is API Gateway, how to implement one in Spring?
Load balancing (what is and why do we need this?)
Inter-Service Communication (FeignClient)
Docker & Kubernetes Basics - images, containers, basic commands
Datadog/Grafana tools (what is observability and why do we need this)
CI/CD tools - just the basics (what is and why do we need this)
Event Driven Architecture - Message Brokers, Message Queues, Publisher, Listener, Events, Kafka
DLQ (dead letter queue)

Testing 🟢
JUnit & Assertions - Unit Tests
Mockito & Mocking Dependencies
Test Lifecycle (@BeforeEach,
@AfterEach
)
@WebMvcTest
 – API Testing
MockMvc
@SpringBootTest
 – Full Context Testing (Integration Testing)
H2 Database
WireMock – Mocking External APIs 🔴
TestContainers 🔴