45-day interview roadmap

Java Backend · Java Backend Engineer Mastery

45-Day Java Backend Engineer Mastery

Learn in place: pick a topic on the left, read the lesson on the right, and mark it complete when you are done.

Start learning Jump to phases

7 min read August 27, 2026

45-day plan — Java Backend

0%0 / 0

Day 1–8 Core Java
Day 9–16 JVM & modern Java
Day 17–29 Spring, JPA & security
Day 30–40 Microservices, Kafka & observability
Day 41–44 Docker & Kubernetes

Curriculum

Phase 1: CORE JAVA FOUNDATIONS

Day 1 – Java Platform, JDK, JRE, JVM & Execution Flow

Topics

What Java is
JDK vs JRE vs JVM
Java compilation process
Source code → bytecode
JVM execution
Platform independence
High-level JVM architecture
How a Java application starts and runs

Day 2 – Java Fundamentals, Classes & Objects

Topics

Variables and data types
Primitive vs reference types
Type conversion and casting
Operators
Control flow
Methods
Parameters and return values
Classes and objects
Object references
Constructors
this
Access modifiers

Day 3 – Object-Oriented Programming

Topics

Encapsulation
Inheritance
Polymorphism
Abstraction
Abstract classes
Interfaces
Default methods
Static interface methods
super
Method overriding vs overloading

Day 4 – Object Class, String & Immutability

Topics

Object class
equals()
hashCode()
toString()
String immutability
String Constant Pool
== vs equals()
StringBuilder
StringBuffer
Wrapper classes
Autoboxing and unboxing
Immutable class design

Phase 2: COLLECTIONS & GENERICS

Day 5 – Collections Framework, List & Queue

Topics

Collections hierarchy
Collection vs Collections
List
ArrayList internals
LinkedList internals
Vector overview
Stack overview
Queue
Deque
ArrayDeque
PriorityQueue
Collection selection

Day 6 – Set & Map

Topics

Set
HashSet
LinkedHashSet
TreeSet
Map
HashMap
LinkedHashMap
TreeMap
Also
Hashing
Buckets/bins
Collision handling
equals() and hashCode()

Day 7 – HashMap Deep Dive & Concurrent Collections

Topics

HashMap put() flow
HashMap get() flow
Hash calculation
Buckets/bins
Collision handling
Treeification
Resize and rehashing
Load factor
ConcurrentHashMap
CopyOnWriteArrayList
Concurrent collections overview

Day 8 – Generics, Comparable & Comparator

Topics

Generic classes
Generic methods
Type safety
Type erasure
Bounded type parameters
Wildcards
?
? extends
? super
Comparable
Comparator
Sorting objects

Phase 3: EXCEPTIONS & MODERN JAVA

Day 9 – Exception Handling & Resource Management

Topics

Checked exceptions
Unchecked exceptions
Error vs Exception
try
catch
finally
throw
throws
Exception propagation
Custom exceptions
Multi-catch
Try-with-resources
Suppressed exceptions

Day 10 – Functional Programming & Java 8+

Topics

Functional interfaces
Lambda expressions
Method references
Predicate
Function
Consumer
Supplier
Built-in functional interfaces
Default methods
Optional
Optional best practices

Day 11 – Stream API

Topics

Stream pipeline
Intermediate operations
Terminal operations
filter
map
flatMap
distinct
sorted
limit
skip
reduce
collect
Collectors
groupingBy
partitioningBy
Parallel streams overview

Phase 4: MULTITHREADING & CONCURRENCY

Day 12 – Threading Fundamentals & Synchronization

Topics

Process vs thread
Thread lifecycle
Creating threads
Thread
Runnable
Callable
Race conditions
Thread safety
synchronized
Object monitor
Intrinsic locks
wait()
notify()
notifyAll()

Day 13 – Java Concurrency & Executor Framework

Topics

volatile
Visibility vs atomicity
Atomic classes
ReentrantLock
ReadWriteLock overview
Executor
ExecutorService
Thread pools
Fixed thread pool
Cached thread pool
Scheduled executor
Future
Callable

Day 14 – Advanced Concurrency & Thread Coordination

Topics

CompletableFuture
Async execution
thenApply
thenCompose
thenCombine
Exception handling
CountDownLatch
CyclicBarrier
Semaphore
Phaser overview
BlockingQueue
Producer-consumer pattern
Deadlock
Livelock
Starvation
ForkJoinPool overview

Phase 5: JVM & MODERN JAVA

Day 15 – JVM, Memory, Class Loading & Garbage Collection

Topics

JVM Architecture
Class Loader
Runtime memory areas
Execution engine
Memory
Stack
Heap
Metaspace
Object allocation
Garbage Collection
Young generation
Eden
Survivor spaces
Old generation
Minor GC
Major GC / Full GC
Class Loading
Loading
Linking
Initialization
Parent delegation model
Problems
Memory leaks
Heap dumps
GC monitoring overview

Day 16 – Modern Java: Java 17 & Java 21

Topics

Java 17
LTS overview
Records
Sealed classes
Pattern matching improvements
Text blocks
Java 21
Virtual Threads
Pattern matching for switch
Record patterns
Sequenced collections
Practical backend focus
When to use Records
DTO use cases
Virtual threads and backend workloads
Modern Java coding practices

Phase 6: SPRING CORE

Day 17 – Spring Core, IoC & Dependency Injection

Topics

Why Spring
IoC
Dependency Injection
Beans
ApplicationContext
Constructor injection
Field injection problems
Setter injection
Dependency resolution
Bean scopes

Day 18 – Bean Lifecycle & Spring Configuration

Topics

Component scanning
Stereotype annotations
@Configuration
@Bean
Bean lifecycle
@PostConstruct
@PreDestroy
Bean initialization
Bean destruction
Conditional beans overview

Phase 7: SPRING BOOT & REST

Day 19 – Spring Boot Fundamentals & Internals

Topics

Why Spring Boot
Starters
Auto-configuration
Embedded server
Spring Boot startup flow
Externalized configuration
Properties
YAML
Profiles

Day 20 – REST APIs with Spring Boot

Topics

@RestController
@RequestMapping
@GetMapping
@PostMapping
@PutMapping
@PatchMapping
@DeleteMapping
Path variables
Request parameters
Request body
ResponseEntity
HTTP status codes

Day 21 – API Design, DTOs & Validation

Topics

REST resource design
URL naming
DTO pattern
Entity vs DTO
Request DTO
Response DTO
Bean Validation
@Valid
Custom validation overview
Pagination
Sorting
Filtering
API versioning basics
Backward compatibility

Day 22 – Exception Handling & API Error Design

Topics

@ControllerAdvice
@ExceptionHandler
Custom exceptions
Global exception handling
ProblemDetail
Error response design
Error codes
Logging exceptions

Phase 8: JPA & DATABASE

Day 23 – JPA & Hibernate Fundamentals

Topics

ORM
JPA vs Hibernate
Entity
Primary keys
ID generation
Persistence context
Entity lifecycle
Dirty checking
Repositories
CRUD

Day 24 – JPA Relationships & Entity Management

Topics

One-to-One
One-to-Many
Many-to-One
Many-to-Many
Owning side
mappedBy
Cascade types
orphanRemoval
Lazy loading
Eager loading

Day 25 – Advanced JPA & Database Performance

Topics

Derived queries
JPQL
Native queries
Pagination
Sorting
Projections
N+1 problem
Fetch joins
Batch operations
Index basics
Query optimization fundamentals

Day 26 – Transactions & Data Consistency

Topics

ACID
@Transactional
Transaction boundaries
Propagation
Isolation
Rollback rules
Read-only transactions
Common transaction problems
Transaction design best practices

Phase 9: SECURITY, TESTING & BACKEND UTILITIES

Day 27 – Spring Security & JWT

Topics

Spring Security
Authentication
Authorization
SecurityFilterChain
Authentication flow
Password encoding
Roles vs authorities
Method security
JWT
JWT structure
Login flow
Token generation
Token validation
JWT filter
Stateless authentication
Access tokens
Refresh tokens

Day 28 – Testing Spring Boot Applications

Topics

Testing strategy
Unit testing
JUnit
Mockito
Service testing
Controller testing
Repository testing
Integration testing
Testcontainers introduction

Day 29 – Production Features & Backend Utilities

Topics

Spring Boot Actuator
Health endpoints
Metrics
Logging
Externalized configuration
Profiles
Graceful shutdown
Caching
Scheduling
@Async
OpenAPI / Swagger
Database migrations
Flyway / Liquibase overview

Phase 10: MICROSERVICES

Day 30 – Monolith vs Microservices

Topics

Monolithic architecture
Microservices architecture
Advantages
Challenges
When to use microservices
When not to use microservices
Migration considerations
Distributed monolith anti-pattern

Day 31 – Microservice Design & Service Boundaries

Topics

Service decomposition
Domain boundaries
High cohesion
Loose coupling
Database per service
Data ownership
API contracts
Avoiding shared databases

Day 32 – Service-to-Service Communication

Topics

Synchronous communication
REST
RestClient
WebClient
Synchronous communication trade-offs
Reliability
Timeout
Retry basics
API compatibility
Backward compatibility

Day 33 – API Gateway

Topics

Why API Gateway
Gateway architecture
Routing
Request filtering
Authentication
Authorization considerations
Rate limiting
Cross-cutting concerns
Spring Cloud Gateway

Day 34 – Service Discovery & Centralized Configuration

Topics

Service Discovery
Service registration
Service discovery
Dynamic service locations
Eureka
Client-side discovery concepts
Configuration
Spring Cloud Config
Centralized configuration
Environment-specific configuration
Configuration refresh considerations

Day 35 – Resilience & Fault Tolerance

Topics

Distributed system failures
Timeouts
Retries
Circuit breaker
Bulkhead
Fallback
Rate limiting concepts
Resilience4j

Day 36 – Distributed Data & Consistency

Topics

Database per service
Distributed transaction problem
Eventual consistency
Idempotency
Data duplication
Outbox pattern
Event-driven consistency

Day 37 – Saga Pattern & Distributed Workflows

Topics

Why Saga
Choreography
Orchestration
Compensating transactions
Saga failure handling
Order/payment/inventory workflow
Idempotent operations in workflows

Phase 11: KAFKA

Day 38 – Kafka Fundamentals

Topics

Why Kafka
Event-driven architecture
Kafka architecture
Broker
Cluster
Topic
Partition
Producer
Consumer
Consumer group
Offset
Ordering
Replication

Day 39 – Kafka with Spring Boot

Topics

Spring Kafka
Producers
Consumers
Serialization
Deserialization
Consumer groups
Offset management
Consumer rebalancing
Retry
Error handling
Dead Letter Topics
Idempotency
Delivery semantics:
At-most-once
At-least-once
Exactly-once concepts

Phase 12: OBSERVABILITY

Day 40 – Observability & Production Debugging

Topics

Logging
Structured logging
Centralized logging
Tracing
Correlation IDs
Distributed tracing
Request tracing across services
Monitoring
Metrics
Health checks
Monitoring concepts
Production debugging
Following one request through multiple services
Identifying failures
Debugging distributed systems

Phase 13: DOCKER

Day 41 – Docker Fundamentals & Spring Boot Containerization

Topics

Docker Fundamentals
Why Docker
Containers vs Virtual Machines
Docker architecture
Docker Client
Docker Daemon
Registry
Images
Containers
Container lifecycle
Dockerfile
FROM
WORKDIR
COPY
RUN
CMD
ENTRYPOINT
EXPOSE
Spring Boot
Build JAR
Build Docker image
Run container
Port mapping
Environment variables
Best Practices
Multi-stage builds
Layer caching
.dockerignore
Small images
Image security basics

Day 42 – Docker Compose & Microservices

Topics

Networking
Bridge networks
Container DNS
Service-to-service communication
Internal ports vs exposed ports
Storage
Docker volumes
Named volumes
Bind mounts
Persistent database data
Docker Compose
compose.yaml
Services
Networks
Volumes
Environment variables
depends_on
Health checks
Service startup considerations
Practical Project
Run
API Gateway
Microservices
Database
Kafka
locally using Docker Compose.

Phase 14: KUBERNETES

Day 43 – Kubernetes Architecture & Application Deployment

Topics

Why Kubernetes
Container orchestration
Scaling
Self-healing
Managing multiple containers
Architecture
Control Plane
API Server
Scheduler
Controller Manager
etcd
Worker Nodes
Kubelet
kube-proxy
Container runtime
Application Objects
Pods
Pod lifecycle
Pod networking
Deployments
ReplicaSets
Desired state
Deployment
Deployment YAML
Scaling replicas
Rolling updates
Services
ClusterIP
NodePort
LoadBalancer
Service discovery
Deploy Spring Boot microservices.

Day 44 – Kubernetes Configuration, Networking & Production Basics

Topics

Configuration
ConfigMaps
Environment variables
Mounted configuration
Secrets
Secrets
Environment variables
Mounted secrets
Health
Liveness probes
Readiness probes
Resources
CPU requests
Memory requests
CPU limits
Memory limits
Scaling
Replicas
Manual scaling
Horizontal Pod Autoscaler
Networking & External Access
Cluster networking basics
DNS
Internal service communication
Ingress
Path-based routing
Host-based routing
Deployment
Rolling deployments
Rollbacks
Zero-downtime deployment concepts

Select a lesson

Open any topic, practice, or interview question from the curriculum to learn here — no new tab.

Keep momentum

Ready to practise what you just planned?

Jump into hands-on problems or read real interview experiences from engineers at your level.

Coding practice Interview experiences

45-Day Java Backend Engineer Mastery

Select a lesson

Lesson

Ready to practise what you just planned?

Create your account

Reset password

Choose a new password