2026 EDITION · JAVA FULL STACK ROADMAP

100-Day Java Full Stack

(Spring Boot) Roadmap
For a learner who already knows basic Java → job-ready Full Stack Java / Spring Boot Developer

100 425 12 5
DAYS STUDY HOURS PHASES PORTFOLIO
PROJECTS

Prepared for placement & interview readiness (TCS-style on-campus drives + product-based companies)
Researched from current 2026 industry sources · Built with Claude
 1. Learning Strategy — Overview

Yeh roadmap un logon ke liye hai jo basic Java already jaante hain aur ek job-ready Java Full Stack / Spring Boot Developer banna chahte hain — chahe on-campus drives (TCS jaisi service-
based companies) ho ya product-based companies. Poori roadmap 4 bade blocks mein divide hai:

1. Foundation (Day 1–30): Core Java revision, Git/GitHub, Maven, SQL, aur HTML/CSS/JS basics — bina in fundamentals ke Spring Boot samajhna mushkil hoga.
2. Backend Mastery (Day 31–76): Spring Core → Spring Boot → REST APIs → JPA/Hibernate → Spring Security/JWT → Testing. Yeh core hai jahan "job-ready" backend developer banta hai.
3. Full Stack + Cloud-Native (Day 77–94): React frontend integration, Microservices basics, Docker, deployment — 2026 ke hiring bar ke liye zaroori.
4. Placement Sprint (Day 95–100): Resume, portfolio, revision, aur interview mock practice.

Hour distribution rule: Har din 4 study hours base hai. Har 4th din ek "Practice / Hands-on Consolidation Day" hai jisme 1 extra hour milta hai (5 hrs) — sirf naya concept padhne ke
bajaye us week ka content practically apply karne ke liye. Yeh 75 days × 4 hrs + 25 practice days × 5 hrs = 425 total hours ban jaata hai. Practice days table mein highlighted (halke
peele) rang mein dikhaye gaye hain.

Golden rule: Pehle 30 din mein naya frontend/backend framework seekhne ki jaldi mat karo — fundamentals (OOP, collections, SQL, Git) pakke karo. In-demand Spring Boot skills sirf tabhi
useful hain jab neeche ki base strong ho, warna interview mein depth ke sawalon pe atkoge.

2. What's Hot, What's Outdated — 2026 Market Reality

Job market data (2025 Stack Overflow Survey, current hiring blogs, and 2026 Java/Spring ecosystem reports) batata hai ki Java + Spring Boot combination abhi bhi enterprise, fintech, aur SaaS
hiring mein top 3–5 mein hai — ~30% developers actively use Java . Lekin the expectations have shifted. Yeh cheatsheet aapko 4–5 saal relevant rakhega:

✅ Learn / Prioritize (2026 in-demand) Don't invest time (declining / legacy)

HOT Spring Boot 3.x/4 (Jakarta namespace, not old javax) OUTDATED JSP + Servlets as a primary web layer (still exists in legacy banking systems,
but new apps don't use it — REST + React replaced it)
HOT REST APIs + JSON — this is the default, not JSP views
OUTDATED Apache Struts — officially going end-of-life, avoid entirely for new learning
HOT React as the frontend pairing for Spring Boot (most common "full stack Java" combo
in 2026 job posts) OUTDATED JSF (JavaServer Faces) — tightly coupled front/back, being phased out

HOT Docker + basic Kubernetes awareness OUTDATED Old Spring XML-based configuration — learn annotation/Java-config only

HOT Spring Security + JWT/OAuth2 stateless auth LOW PRIORITY SOAP web services (only relevant in specific legacy banking/telecom
projects — know the concept, don't deep-dive)
HOT Cloud basics — pick ONE of AWS/Azure/GCP, deploy something real
LOW PRIORITY jQuery-heavy frontend approaches — modern stacks use React/Vue
HOT Kafka / event-driven basics (conceptual, growing fast in job posts)
instead
HOT Flyway/Liquibase for DB migrations, Testcontainers for integration tests CONTEXT ONLY Servlets fundamentals — worth understanding conceptually (Spring MVC

HOT Observability basics (logging, Actuator, OpenTelemetry — awareness level) is built on them) but not as a coding focus

GOOD TO KNOW Virtual threads (Java 21+), Java streams/records

TCS / service-based company note: In-house training methodology (like TCS's internal onboarding) still uses Core Java, JDBC, and sometimes legacy patterns for teaching fundamentals
— that's normal and doesn't contradict this roadmap. On-campus interviews at service companies focus heavily on Core Java, OOP, DBMS/SQL, basic aptitude, and communication —
not cutting-edge tech. Product-based/startup interviews go deeper into Spring Boot internals, system design basics, and your projects. This roadmap covers both.

3. Day-Wise 100-Day Plan (Total: 425 hours)

Day Hrs Topic / What to Study Phase Focus

PHASE 1 · CORE JAVA REVISION & ADVANCED CONCEPTS (Day 1–14)

1 4 Java recap: JVM/JDK/JRE, data types, operators, control flow (quick revision, not from scratch) Core Java

2 4 OOP: classes, objects, constructors, this/super, encapsulation Core Java

3 4 Inheritance, polymorphism (overloading/overriding), abstract class vs interface Core Java

4 5 Practice day: Design and code a small class hierarchy (e.g., Vehicle/Employee system) using everything from Day 1–3 Practice

5 4 Static/final/access modifiers, packages, wrapper classes, autoboxing/unboxing Core Java

6 4 Collections Framework overview: List, Set, Map interfaces, ArrayList vs LinkedList Core Java

7 4 HashMap, TreeMap, HashSet, LinkedHashSet, Comparable vs Comparator Core Java

8 5 Practice day: Collections-based problems (word frequency counter, employee sorting by multiple fields) Practice

9 4 Exception handling: checked/unchecked, try-catch-finally, try-with-resources, custom exceptions Core Java

10 4 Java 8: lambda expressions, functional interfaces, method references Core Java

11 4 Java Streams API: map/filter/reduce/collect, Optional class Core Java

12 5 Practice day: Streams-based data processing problems (group/sort/aggregate a list of objects) Practice

13 4 Multithreading basics: Thread class, Runnable, thread lifecycle, synchronized Core Java

14 4 Executor framework, thread pools, concurrency utilities overview (CountDownLatch, etc.) Core Java

PHASE 2 · GIT, GITHUB & BUILD TOOLS (Day 15–18)

15 4 Git basics: init, clone, add, commit, status, log, branching Git/GitHub

16 5 Practice day: Branching, merging, resolving conflicts + push a Core Java practice repo to GitHub Practice

17 4 GitHub workflow: pull requests, issues, README writing, .gitignore, collaboration basics Git/GitHub

18 4 Maven: project structure, [Link], dependency management, build lifecycle (+ Gradle overview) Build Tools

PHASE 3 · HTML, CSS & JAVASCRIPT BASICS (Day 19–25)

19 4 HTML5: structure, forms, semantic elements, tables Frontend Basics

20 5 Practice day: CSS box model, flexbox, grid, responsive design + build a styled profile page Practice

21 4 JavaScript fundamentals: variables, functions, arrays, objects, DOM manipulation Frontend Basics

22 4 JS events, fetch API, async/await, working with JSON Frontend Basics

23 4 Practice: build a small interactive vanilla-JS to-do list (DOM + events) Frontend Basics

24 5 Practice day: Intro to Tailwind CSS (modern utility-first styling, widely used in 2026) + revision Practice

25 4 Wrap-up: why full stack Java developers need frontend skills; how backend and frontend will connect later (preview) Frontend Basics

PHASE 4 · SQL & DATABASES (Day 26–30)

26 4 SQL basics: DDL/DML, SELECT, WHERE, ORDER BY, aggregate functions SQL

27 4 Joins (inner/left/right/full), GROUP BY, HAVING, subqueries SQL

28 5 Practice day: Write 20+ SQL queries on a sample schema (Employee/Orders DB) + install MySQL/PostgreSQL locally Practice

29 4 Database design basics: normalization, primary/foreign keys, indexes, simple ER diagrams SQL

30 4 JDBC basics: Connection, Statement, PreparedStatement, ResultSet — simple JDBC CRUD SQL

PHASE 5 · SPRING CORE & SPRING BOOT FUNDAMENTALS (Day 31–45)

31 4 Introduction to Spring Framework: Inversion of Control (IoC) and Dependency Injection concepts Spring Core

32 5 Practice day: Create Spring beans, @Component, @Autowired, ApplicationContext hands-on Practice

33 4 Bean lifecycle, bean scopes, @Configuration, @Bean, Java-based config (skip XML config) Spring Core

34 4 Introduction to Spring Boot: auto-configuration, starters, Spring Initializr Spring Boot

35 4 Build your first Spring Boot app: project structure, [Link]/yml Spring Boot

36 5 Practice day: Build a "Hello World" Spring Boot REST app, run and debug it in IntelliJ IDEA Practice

37 4 Spring Boot annotations deep-dive: @SpringBootApplication, @RestController, @RequestMapping Spring Boot

38 4 Building REST endpoints: GET/POST/PUT/DELETE, @PathVariable, @RequestParam, @RequestBody REST APIs

39 4 Layered architecture: Controller → Service → Repository pattern, DTOs Spring Boot

40 5 Practice day / Project 1 kickoff: Build a simple in-memory CRUD REST API — Student/Employee Management System Project

41 4 Dependency Injection deep-dive: constructor vs field vs setter injection, best practices Spring Core

42 4 Spring profiles, externalized configuration, environment-specific configs (dev/test/prod) Spring Boot

43 4 API testing & documentation: Postman collections, Swagger/OpenAPI basics Tools

44 5 Practice day: Document and test all endpoints with Swagger/Postman; polish the CRUD API Practice

45 4 Revision day: Spring Core + Spring Boot concept review, self Q&A notes Revision

PHASE 6 · REST VALIDATION, EXCEPTION HANDLING & LOGGING (Day 46–52)

46 4 Bean validation: @Valid, @NotNull, @Size, @Email, writing custom validators REST APIs

47 4 Global exception handling: @ControllerAdvice, @ExceptionHandler, structured error responses REST APIs

48 5 Practice day: Add validation + centralized exception handling to your CRUD API Practice

49 4 Logging: SLF4J, Logback, log levels, production logging best practices REST APIs

50 4 API versioning, pagination, sorting, and filtering in REST APIs REST APIs

51 4 HTTP status codes, REST best practices, brief HATEOAS overview REST APIs

52 5 Practice day: Refactor CRUD API with pagination, sorting, filtering and correct status codes Practice

PHASE 7 · JPA, HIBERNATE & DATABASE INTEGRATION (Day 53–62)

53 4 Introduction to ORM, Spring Data JPA basics, entity mapping (@Entity, @Id, @Table) JPA/Hibernate

54 4 Repository pattern: JpaRepository, CrudRepository, derived query methods JPA/Hibernate

55 4 Entity relationships: @OneToMany, @ManyToOne, @ManyToMany, cascade types JPA/Hibernate

56 5 Practice day: Model a real schema (Employee–Department) with relationships end-to-end Practice

57 4 JPQL and native queries, @Query annotation, query parameters JPA/Hibernate

58 4 Hibernate internals: first/second-level cache, lazy vs eager loading, N+1 problem JPA/Hibernate

59 4 Transactions: @Transactional, isolation levels, rollback rules JPA/Hibernate

60 5 Practice day / Project 2 build: Integrate MySQL/PostgreSQL with full CRUD + relationships — Leave Management System Project
backend

61 4 Flyway/Liquibase basics for database version control and migrations (modern industry practice) JPA/Hibernate

62 4 Revision + checkpoint: connect everything built so far end-to-end, fix bugs Revision

PHASE 8 · SPRING SECURITY, JWT & AUTHENTICATION (Day 63–71)

63 4 Spring Security basics: filter chain, authentication vs authorization concepts Security

64 5 Practice day: In-memory auth, UserDetailsService, password encoding (BCrypt) hands-on Practice

65 4 Role-based access control: @PreAuthorize, method-level security Security

66 4 JWT concepts: tokens, claims, signing, stateless authentication Security

67 4 Implementing JWT auth filter, login/register endpoints Security

68 5 Practice day: Secure your CRUD/Leave Management API with JWT login/register + role-based endpoints Practice

69 4 OAuth2 basics and social login overview (conceptual — good to know for interviews) Security

70 4 Securing REST APIs: CORS, CSRF, security headers, OWASP Top 10 basics Security
 70 4 Securing REST APIs: CORS, CSRF, security headers, OWASP Top 10 basics Security

71 4 Revision + polish the security module in your main project Revision

PHASE 9 · TESTING: JUNIT & MOCKITO (Day 72–76)

72 5 Practice day: JUnit 5 basics — annotations, assertions, test lifecycle Practice

73 4 Mockito: mocking dependencies, @Mock, @InjectMocks, verify() Testing

74 4 Writing unit tests for service and controller layers Testing

75 4 Integration testing: @SpringBootTest, MockMvc, TestRestTemplate Testing

76 5 Practice day: Write test coverage for your main project (aim for 70%+ on core logic) Practice

PHASE 10 · REACT FRONTEND & FULL STACK INTEGRATION (Day 77–86)

77 4 React basics: components, JSX, props, state React

78 4 React hooks: useState, useEffect, event handling React

79 4 Practice: build a small component tree (reusable Card/List/Form components) React

80 5 Practice day: React Router, forms handling, controlled components hands-on Practice

81 4 Connecting React to Spring Boot REST API: axios/fetch, handling CORS Full Stack

82 4 Building a full CRUD UI in React consuming your Spring Boot backend Full Stack

83 4 State management basics (Context API / lightweight state), conditional rendering React

84 5 Practice day / Project 3 build: Complete the frontend for Leave Management System (list, add, edit, approve/reject UI) Project

85 4 UI polish: Tailwind/Bootstrap styling, loading states, error handling in the UI Full Stack

86 4 Wire up JWT authentication in React: login page, protected routes, token storage Full Stack

PHASE 11 · MICROSERVICES, DOCKER & DEPLOYMENT (Day 87–94)

87 4 Microservices concepts: monolith vs microservices, when (and when not) to use them Microservices

88 5 Practice day: Spring Cloud basics — service discovery (Eureka), API Gateway overview, hands-on setup Practice

89 4 Inter-service communication: REST clients, Feign client basics Microservices

90 4 Docker basics: images, containers, Dockerfile, docker-compose Docker

91 4 Practice: containerize your Spring Boot app + MySQL using docker-compose Docker

92 5 Practice day: CI/CD basics — GitHub Actions overview, deployment pipeline concepts Practice

93 4 Cloud deployment basics: deploy backend+DB to a free-tier cloud host, managing env variables Deployment

94 4 Project 4 milestone: Deploy your full-stack project (backend + frontend) live and get a working link Project

PHASE 12 · RESUME, PORTFOLIO & INTERVIEW SPRINT (Day 95–100)

95 4 Build/finalize resume: ATS-friendly format, project descriptions, quantify impact Career Prep

96 5 Practice day: GitHub portfolio polish — README files, pinned repos, LinkedIn profile update Career Prep

97 4 Core Java + Spring Boot interview theory revision (OOP, collections, Spring internals) Interview Prep

98 4 SQL revision + basic system design for interviews (how a REST API scales, DB indexing recap) Interview Prep

99 4 Mock interview practice: explain your projects clearly, common HR + technical questions Interview Prep

100 5 Final day: Review weak areas, DSA practice (recursion/backtracking/arrays), confidence building Interview Prep

TOTAL: 100 Days · 425 Hours (75 days × 4 hrs + 25 practice days × 5 hrs)

4. Project Ideas (Build These Along the Roadmap)

Sirf project ideas diye gaye hain — full code nahi. Har project ek specific roadmap-checkpoint pe build hoga taaki aap seekha hua concept turant apply karo. In sab ko GitHub pe push karo,
README ke saath.

1. Employee / Student Management System (CRUD API)

When: Day 40 (after Spring Boot + REST basics) | Why relevant: Yeh classic OA/interview-style problem hai — Controller-Service-Repository layering test karta hai, aur almost har company iska variant puchti
hai.
How (short): Start in-memory (List/Map), then Day 60 pe MySQL se connect karo. Endpoints: add/update/delete/search employee, filter by department.

2. Task Manager with JWT Authentication

When: Day 60–68 (after JPA + Spring Security) | Why relevant: Demonstrates a complete auth flow — login/register, protected endpoints, per-user data — a very common interview/OA scenario.
How (short): Spring Boot + JPA + MySQL + JWT. Each task belongs to a logged-in user; add priority/due-date fields and status filters.

3. Leave Management System (Main Capstone-in-Progress)

When: Backend Day 56–60, Frontend Day 77–86 | Why relevant: Real enterprise use case with relationships (Employee–Manager–LeaveRequest) and an approval workflow — shows you can model realistic
business logic, not just simple CRUD.
How (short): Spring Boot backend with role-based access (Employee vs Manager), React frontend for applying/approving/rejecting leaves.

4. Order Management / Mini E-commerce Backend

When: Day 87–94 (Microservices + Docker phase) | Why relevant: Shows scalability thinking — splitting a system into services (Product, Order, Inventory) is exactly what 2026 job posts ask about
("microservices experience").
How (short): 2–3 small Spring Boot services communicating over REST/Feign, registered with Eureka, run together via docker-compose.

5. Capstone: Ticket Booking System or Banking-Style Ledger

 When: Day 95–100 (polish phase, using Day 94's deployment pipeline) | Why relevant: This becomes your resume centerpiece — a full-stack, secured, tested, deployed project shows end-to-end ownership.
How (short): Combine everything: Spring Boot + Spring Security/JWT + JPA + React + Docker, deployed with a live link and a well-written README (with architecture diagram if possible).

5. Learning Resources (Free & High-Quality)

Resource Language Best For

Telusko (YouTube — Navin Reddy) English Java to Spring Boot, one of the most complete free progressions available; good for Day 1–45

Apna College (YouTube) Hinglish DSA + placement-prep style teaching; good companion for your existing recursion/backtracking study and Day 95–100 revision

Kunal Kushwaha (YouTube) Hinglish Backend + DSA explained with strong fundamentals-first approach

Durgasoft (YouTube) Hinglish/Telugu-English Java teaching style aligned with service-based company (TCS/Infosys-style) interview expectations

CodeWithHarry (YouTube) Hindi HTML/CSS/JS basics — good for Day 19–25 frontend block

Amigoscode (YouTube) English Modern Spring Boot + Docker + microservices + React integration — matches 2026 industry practice closely

Java Brains (YouTube) English Deep conceptual explanations of Spring internals (DI, bean lifecycle) — use when you want the "why", not just the "how"

Spring Academy ([Link] — English Official, up-to-date for Spring 6 / Spring Boot 3+; best single source for Spring Core + Boot fundamentals
official, free)

Baeldung ([Link]) English Best reference articles for specific Spring/Java problems — use like documentation, not a course

GeeksforGeeks English Quick reference for Java, Collections, SQL, and DSA concepts

MDN Web Docs English Authoritative HTML/CSS/JavaScript reference for Day 19–25

LeetCode / Striver's A2Z-SDE Sheet / English DSA + coding round practice — continue alongside this roadmap using your existing recursion/backtracking base
CSES

6. Interview Preparation Section

Core areas to be interview-ready

Core Java: OOP pillars, collections internals (HashMap working), exception hierarchy, streams/lambda usage, multithreading basics
Spring Boot: what auto-configuration does, DI types, bean scopes, how a request flows Controller → Service → Repository, common annotations
Database: joins, indexing, normalization, ACID, transactions — SQL query-writing round is very common
Project deep-dive: be ready to explain your Leave Management / capstone project — architecture, why you chose JWT over sessions, how you'd scale it
System design basics: not full HLD — just be able to explain how a REST API handles load, what caching/indexing does, monolith vs microservices trade-offs
Behavioral/HR round: "tell me about yourself," project ownership stories, why this company

For TCS-style / service-based on-campus drives: expect a stronger focus on aptitude, Core Java fundamentals, DBMS basics, OS/CN basics, and communication rounds over deep
Spring Boot internals. Keep practicing easy-medium DSA (your recursion/backtracking work fits perfectly here) alongside this roadmap — don't drop that for Spring Boot content.

For product-based companies/startups: expect deeper Spring Boot/JPA questions, and they will probe your projects' design decisions in detail — so know every choice you made in your
capstone project and be ready to justify it.

100-Day Java Full Stack (Spring Boot) Roadmap — 2026 Edition · Researched & compiled with Claude · Total: 100 days / 425 hours