52-Day Java Full Stack + DSA + Aptitude +

JavaScript + SQL Roadmap

This 52-day roadmap is designed to transform you into a proficient Java Full Stack developer
while mastering Data Structures and Algorithms (DSA), Aptitude, JavaScript, SQL, and Git for
version control. Each day includes specific topics, practice tasks, and resources to ensure
comprehensive learning and practical application. The plan progresses from basics to advanced
topics, culminating in full-stack projects and interview preparation.

Week 1: Core Java Basics + Aptitude + JavaScript Basics

Goal: Build a strong foundation in Java, start JavaScript, and cover basic aptitude.

Day 1: Java Setup + Number Systems + JavaScript Intro

 Java: Understand JDK, JRE, JVM; install Java and set up IDE (e.g., IntelliJ IDEA or VS
Code).
 JavaScript: Introduction to JavaScript; set up Node.js and VS Code for JS; run basic
console.log programs.
 Aptitude: Number Systems (Natural, Whole, Integers, Rational, Irrational).
 Practice:
o Java: Write a "Hello, World!" program.
o JavaScript: Create a script to print numbers 1 to 10.
o Aptitude: Solve 5 percentage calculation problems.
 Resources: Oracle Java Docs, W3Schools JavaScript, IndiaBix Number Systems.

Day 2: Java Variables + LCM/HCF + JavaScript Variables

 Java: Variables, Data Types (int, double, String, etc.), Operators (arithmetic, relational,
logical).
 JavaScript: Variables (let, const, var), Data Types, Basic Operators.
 Aptitude: LCM and HCF basics and problems.
 Practice:
o Java: Program to calculate area of a rectangle using variables.
o JavaScript: Program to swap two variables.
o Aptitude: Solve 5 LCM/HCF problems.
 Resources: W3Schools Java Data Types, W3Schools JavaScript Variables, IndiaBix
LCM/HCF.

Day 3: Java Methods + Arrays + Time/Speed/Distance + JavaScript Functions

  Java: Methods (declaration, parameters, return types, overloading); 1D Arrays
(declaration, initialization, traversal).
 JavaScript: Functions (declaration, expression, arrow functions), basic function calls.
 DSA: Array problems (sum, max, reverse) – Striver A2Z Day 2.
 Aptitude: Time, Speed, Distance basics.
 Practice:
o Java: Write a method to find the factorial of a number; traverse an array.
o JavaScript: Create a function to calculate the square of a number.
o DSA: Solve 3 array problems (e.g., find max element).
o Aptitude: Solve 5 Time/Speed/Distance problems.
 Resources: GeeksforGeeks Java Methods, W3Schools JavaScript Functions, Striver A2Z
Arrays.

Day 4: Java OOP + 2D Arrays + Interest + JavaScript Arrays

 Java: OOP basics (classes, objects, constructors, this keyword); 2D Arrays (declaration,
traversal, sum).
 JavaScript: Arrays (creation, methods like push, pop, map).
 DSA: 2D array problems – Striver A2Z Day 3.
 Aptitude: Simple Interest and Compound Interest formulas.
 Practice:
o Java: Create a Student class with attributes and methods; sum elements in a 2D
array.
o JavaScript: Write a script to filter even numbers from an array.
o DSA: Solve 3 2D array problems (e.g., matrix sum).
o Aptitude: Solve 5 interest problems.
 Resources: Tutorialspoint OOP, W3Schools JavaScript Arrays, GeeksforGeeks 2D
Arrays.

Day 5: Java Control Flow + Arrays Advanced + Profit/Loss + JavaScript Conditionals

 Java: Control Flow (if-else, switch-case) with examples.

 JavaScript: Conditionals (if-else, ternary operator, switch).
 DSA: Advanced array problems (two-pointer, frequency count).
 Aptitude: Profit and Loss problems.
 Practice:
o Java: Write a program to grade students using if-else; solve a two-pointer array
problem.
o JavaScript: Create a script to check if a number is positive, negative, or zero.
o DSA: Solve 3 array problems (e.g., find pair with given sum).
o Aptitude: Solve 5 Profit/Loss problems.
 Resources: W3Schools Java Control Flow, W3Schools JavaScript Conditionals, IndiaBix
Profit/Loss.

Day 6: Java Loops + Strings + Averages + JavaScript Loops

  Java: Loops (for, while, do-while), nested loops; String basics (declaration, methods,
substring).
 JavaScript: Loops (for, while, forEach).
 DSA: String manipulation problems.
 Aptitude: Average problems.
 Practice:
o Java: Print a pattern using nested loops; reverse a string.
o JavaScript: Write a loop to sum array elements.
o DSA: Solve 3 string problems (e.g., check palindrome).
o Aptitude: Solve 5 average problems.
 Resources: GeeksforGeeks Java Loops, W3Schools JavaScript Loops, Striver A2Z
Strings.

Day 7: Java Strings + Ratio/Proportion + JavaScript String Methods

 Java: Advanced String methods (equals, compareTo, StringBuilder).

 JavaScript: String methods (slice, substring, split, join).
 DSA: String problems (e.g., anagram check).
 Aptitude: Ratio and Proportion problems.
 Practice:
o Java: Implement a method to check if two strings are anagrams using
StringBuilder.
o JavaScript: Write a script to count vowels in a string.
o DSA: Solve 3 string problems (e.g., longest common prefix).
o Aptitude: Solve 5 Ratio/Proportion problems.
 Resources: Java String API Docs, W3Schools JavaScript Strings, IndiaBix
Ratio/Proportion.

Week 2: Intermediate Java + DSA (Collections, Stacks,

Queues) + Aptitude + JavaScript + SQL Intro
Goal: Deepen Java knowledge, introduce collections, start SQL, and continue JavaScript and
DSA.

Day 8: Java Collections + Arrays/Strings + Partnership + JavaScript Objects

 Java: ArrayList (add, remove, iterate); revisit arrays and strings.

 JavaScript: Objects (creation, properties, methods).
 DSA: Medium-level array and string problems – Striver A2Z Day 4.
 Aptitude: Partnership problems.
 Practice:
o Java: Create a program to manage a list of names using ArrayList.
o JavaScript: Create an object to store student data and access it.
 o DSA: Solve 3 array/string problems (e.g., rotate array).
o Aptitude: Solve 5 partnership problems.
 Resources: Oracle Java Collections, W3Schools JavaScript Objects, IndiaBix
Partnership.

Day 9: Java Wrapper Classes + Stack + Work/Time + JavaScript Arrays Advanced

 Java: Wrapper classes (Integer, Double), Autoboxing/Unboxing.

 JavaScript: Advanced array methods (filter, reduce, find).
 DSA: Stack introduction and problems (e.g., valid parentheses).
 Aptitude: Work and Time problems.
 Practice:
o Java: Convert primitive array to ArrayList using wrapper classes.
o JavaScript: Use reduce to sum an array.
o DSA: Solve 3 stack problems.
o Aptitude: Solve 5 Work/Time problems.
 Resources: GeeksforGeeks Wrapper Classes, W3Schools JavaScript Array Methods,
IndiaBix Work/Time.

Day 10: Java Exception Handling + Queue + Pipes/Cisterns + SQL Basics

 Java: Exception Handling (try, catch, finally, throw, throws).

 JavaScript: Error handling (try-catch).
 SQL: Introduction to SQL; basic SELECT queries; set up MySQL or PostgreSQL.
 DSA: Queue introduction and problems (e.g., implement queue using arrays).
 Aptitude: Pipes and Cisterns problems.
 Practice:
o Java: Write a program with custom exception handling.
o JavaScript: Handle errors in a function that processes user input.
o SQL: Write 3 SELECT queries to retrieve data from a sample table.
o DSA: Solve 3 queue problems.
o Aptitude: Solve 5 Pipes/Cisterns problems.
 Resources: Java Exception Handling Tutorials, W3Schools JavaScript Errors,
W3Schools SQL, IndiaBix Pipes/Cisterns.

Day 11: Java File Handling + Linked List + Interest Advanced + SQL Joins

 Java: File Handling (FileReader, FileWriter, BufferedReader).

 JavaScript: Introduction to JSON for file data handling.
 SQL: SQL Joins (INNER, LEFT, RIGHT, FULL).
 DSA: Linked List introduction and problems (e.g., reverse linked list).
 Aptitude: Advanced Simple/Compound Interest problems.
 Practice:
o Java: Read and write to a text file.
o JavaScript: Parse and create JSON data.
o SQL: Write 3 join queries on sample tables.
 o DSA: Solve 3 linked list problems.
o Aptitude: Solve 5 interest problems.
 Resources: Oracle File Handling Docs, W3Schools JavaScript JSON, W3Schools SQL
Joins, IndiaBix Interest.

Day 12: Java Multithreading + Recursion + Percentage + SQL Aggregates

 Java: Multithreading basics (Thread class, Runnable interface).

 JavaScript: Asynchronous JavaScript (callbacks, setTimeout).
 SQL: Aggregate functions (COUNT, SUM, AVG, MAX, MIN).
 DSA: Recursion basics and problems (e.g., factorial, Fibonacci).
 Aptitude: Percentage increase/decrease problems.
 Practice:
o Java: Create two threads to print numbers concurrently.
o JavaScript: Write an async function using callbacks.
o SQL: Write 3 queries using aggregate functions.
o DSA: Solve 3 recursion problems.
o Aptitude: Solve 5 percentage problems.
 Resources: Java Multithreading Tutorial, W3Schools JavaScript Async, W3Schools SQL
Aggregates, IndiaBix Percentage.

Day 13: Java Collections + Binary Search + Discount + Git Intro

 Java: Collections Framework (List, Set, Map); focus on HashMap, HashSet.

 JavaScript: ES6 features (let/const, arrow functions, destructuring).
 SQL: Subqueries and basic indexing.
 DSA: Binary Search implementation and problems.
 Aptitude: Discount and Marked Price problems.
 Git: Introduction to Git; set up Git; learn git init, git add, git commit.
 Practice:
o Java: Implement a phonebook using HashMap.
o JavaScript: Rewrite a function using arrow functions and destructuring.
o SQL: Write 3 subqueries on sample data.
o DSA: Solve 3 binary search problems (e.g., search in rotated array).
o Aptitude: Solve 5 discount problems.
o Git: Create a repository and commit a simple Java file.
 Resources: Oracle Collections Tutorial, W3Schools JavaScript ES6, W3Schools SQL
Subqueries, Git Docs, IndiaBix Discount.

Day 14: Java 8 Features + Binary Search Practice + Work/Time + JavaScript Promises

 Java: Java 8 Features (Lambdas, Streams, forEach).

 JavaScript: Promises and async/await.
 SQL: GROUP BY and HAVING clauses.
 DSA: Binary Search practice problems.
 Aptitude: Advanced Work and Time problems.
  Practice:
o Java: Use Streams to filter and map a list.
o JavaScript: Fetch data using async/await.
o SQL: Write 3 GROUP BY queries with HAVING.
o DSA: Solve 3 binary search problems.
o Aptitude: Solve 5 Work/Time problems.
 Resources: Java 8 Tutorials, W3Schools JavaScript Promises, W3Schools SQL GROUP
BY, IndiaBix Work/Time.

Week 3: Advanced Java + DSA (Trees, Graphs) + Aptitude

+ JavaScript + SQL
Goal: Learn advanced Java, backend development, trees/graphs, and deepen SQL and
JavaScript.

Day 15: JDBC + Trees + Averages/Mixtures + JavaScript DOM

 Java: JDBC basics (connect to MySQL, execute queries).

 JavaScript: DOM manipulation (select elements, event listeners).
 SQL: Advanced SELECT queries with sorting and filtering.
 DSA: Binary Tree basics (preorder, inorder, postorder traversal).
 Aptitude: Averages and Mixtures problems.
 Practice:
o Java: Connect to MySQL and retrieve data from a table.
o JavaScript: Create a button that changes text on click.
o SQL: Write 3 advanced SELECT queries.
o DSA: Implement tree traversals.
o Aptitude: Solve 5 Averages/Mixtures problems.
 Resources: JDBC Tutorials, W3Schools JavaScript DOM, W3Schools SQL, Striver A2Z
Trees, IndiaBix Averages.

Day 16: Servlets + BST + Speed/Distance + JavaScript Events

 Java: Servlets introduction (create a simple servlet).

 JavaScript: Event handling (click, input, mouse events).
 SQL: SQL constraints (PRIMARY KEY, FOREIGN KEY, UNIQUE).
 DSA: Binary Search Tree (insert, search).
 Aptitude: Advanced Speed and Distance problems.
 Practice:
o Java: Create a servlet to display a welcome message.
o JavaScript: Add event listeners for form input validation.
o SQL: Create a table with constraints.
o DSA: Solve 3 BST problems.
 o Aptitude: Solve 5 Speed/Distance problems.
 Resources: Servlet Tutorials, W3Schools JavaScript Events, W3Schools SQL
Constraints, IndiaBix Speed/Distance.

Day 17: JSP + Graphs + Ratio/Proportion + JavaScript Fetch

 Java: JSP basics (create a simple JSP page).

 JavaScript: Fetch API for HTTP requests.
 SQL: SQL Views and Stored Procedures.
 DSA: Graph basics (DFS, BFS, adjacency list).
 Aptitude: Advanced Ratio and Proportion problems.
 Practice:
o Java: Create a JSP page to display user input.
o JavaScript: Fetch data from a public API (e.g., JSONPlaceholder).
o SQL: Create a view and a stored procedure.
o DSA: Implement DFS and BFS.
o Aptitude: Solve 5 Ratio/Proportion problems.
 Resources: JSP Tutorials, W3Schools JavaScript Fetch, W3Schools SQL Views, Striver
A2Z Graphs, IndiaBix Ratio/Proportion.

Day 18: Spring Boot Intro + Graphs + Profit/Loss + Git Branching

 Java: Spring Boot introduction and setup (create a basic app).

 JavaScript: Introduction to npm and installing dependencies.
 SQL: SQL Triggers and basic performance tuning.
 DSA: Graph problems (shortest path basics, e.g., BFS).
 Aptitude: Complex Profit and Loss problems.
 Git: Branching and merging (git branch, git merge).
 Practice:
o Java: Set up a Spring Boot project with a REST endpoint.
o JavaScript: Create a project with npm and install Axios.
o SQL: Write a trigger for a table update.
o DSA: Solve 3 graph problems.
o Aptitude: Solve 5 Profit/Loss problems.
o Git: Create a branch, make changes, and merge to main.
 Resources: Spring Boot Guide, npm Docs, W3Schools SQL Triggers, IndiaBix
Profit/Loss, Git Docs.

Day 19: Spring Boot REST + DP Intro + Interest + JavaScript Modules

 Java: Spring Boot REST API development (CRUD operations).

 JavaScript: ES6 Modules (import/export).
 SQL: SQL Transactions and ACID properties.
 DSA: Dynamic Programming intro (Fibonacci, Knapsack).
 Aptitude: Compound Interest and Annuity problems.
 Practice:
 o Java: Create a REST API for a todo list.
o JavaScript: Split code into modules for a small app.
o SQL: Write a transaction to update multiple tables.
o DSA: Solve 3 DP problems.
o Aptitude: Solve 5 interest problems.
 Resources: Spring Boot Tutorials, W3Schools JavaScript Modules, W3Schools SQL
Transactions, Striver A2Z DP, IndiaBix Interest.

Day 20: Spring Security + DP + Work/Time + JavaScript Frameworks

 Java: Spring Security basics (authentication, authorization).

 JavaScript: Introduction to React (components, JSX).
 SQL: SQL Normalization (1NF, 2NF, 3NF).
 DSA: DP problems (e.g., longest common subsequence).
 Aptitude: Advanced Work and Time problems.
 Practice:
o Java: Add basic authentication to a REST API.
o JavaScript: Create a React component to display a list.
o SQL: Normalize a sample database schema.
o DSA: Solve 3 DP problems.
o Aptitude: Solve 5 Work/Time problems.
 Resources: Spring Security Guide, React Official Docs, W3Schools SQL Normalization,
IndiaBix Work/Time.

Day 21: Hibernate + DP + Time/Distance + React State

 Java: Hibernate ORM basics (entity mapping, CRUD).

 JavaScript: React State and Props.
 SQL: Advanced SQL queries (nested queries, joins with aggregates).
 DSA: DP problems continued (e.g., 0/1 Knapsack).
 Aptitude: Complex Time and Distance problems.
 Practice:
o Java: Create a Hibernate app to save/retrieve data.
o JavaScript: Build a counter app with React state.
o SQL: Write 3 complex SQL queries.
o DSA: Solve 3 DP problems.
o Aptitude: Solve 5 Time/Distance problems.
 Resources: Hibernate Tutorials, React Official Docs, W3Schools SQL, IndiaBix
Time/Distance.

Week 4: Full Stack Integration + Advanced DSA + Aptitude

+ JavaScript + SQL
Goal: Start full-stack development, deepen DSA, and continue aptitude, JavaScript, and SQL.

Day 22: Git for Projects + Project Setup

 Java: Spring Boot project setup with MySQL.

 JavaScript: Set up a React project with npm.
 SQL: Design a database schema for a project (e.g., Todo app).
 Git: Remote repositories (git push, git pull, GitHub).
 DSA: Solve medium array problems.
 Aptitude: Mixed problems (Percentage, Profit/Loss).
 Practice:
o Java: Initialize a Spring Boot project with MySQL dependency.
o JavaScript: Create a React app using create-react-app.
o SQL: Design tables for a Todo app.
o Git: Push a project to GitHub.
o DSA: Solve 3 array problems.
o Aptitude: Solve 5 mixed problems.
 Resources: Spring Boot Guide, React Official Docs, GitHub Docs, Striver A2Z Arrays,
IndiaBix.

Day 23-28: Full Stack Project + DSA + Aptitude

 Java: Build a REST API with Spring Boot (CRUD for Todo app).
 JavaScript: Create React frontend (components, API integration).
 SQL: Implement database operations (insert, update, delete).
 Git: Use branches for features, commit regularly.
 DSA: Solve medium-hard problems (arrays, strings, trees) – Striver A2Z.
 Aptitude: Mixed problems from all previous topics.
 Practice (Daily):
o Java: Add one endpoint per day (e.g., GET, POST, PUT, DELETE).
o JavaScript: Build one React component per day (e.g., form, list).
o SQL: Write queries to support CRUD operations.
o Git: Commit daily changes, resolve merge conflicts.
o DSA: Solve 3-5 problems daily (e.g., tree traversals, string algorithms).
o Aptitude: Solve 5 mixed problems daily.
 Resources: Baeldung Spring Boot, React Official Docs, W3Schools SQL, Striver A2Z,
IndiaBix.

Week 5: Advanced Frontend + Interview Prep DSA +

Aptitude
Goal: Master React, advanced DSA, and aptitude; integrate frontend with backend.
Day 29-35: React Advanced + DSA + Aptitude

 Java: Enhance Spring Boot API (add validation, error handling).

 JavaScript: React advanced topics (Hooks, Routing with React Router, State
Management with Context/Redux).
 SQL: Optimize queries, add indexes, and handle large datasets.
 Git: Collaborate on GitHub (pull requests, code reviews).
 DSA: Graph problems (Dijkstra’s, topological sort), DP advanced problems (e.g., longest
palindromic substring).
 Aptitude: Mock tests on mixed topics.
 Practice (Daily):
o Java: Add one advanced feature to API (e.g., JWT authentication).
o JavaScript: Build one advanced React feature (e.g., dynamic routing).
o SQL: Optimize one query or add an index.
o Git: Create a pull request for a feature.
o DSA: Solve 3-5 problems daily (focus on graphs, DP).
o Aptitude: Solve 5-10 mock test problems daily.
 Resources: Spring Boot Tutorials, React Official Docs, W3Schools SQL, Striver A2Z,
PrepInsta Aptitude.

Week 6-7: Full Stack Project + Revision + Interview Prep

Goal: Build and deploy a full-stack app, revise all topics, and prepare for interviews.

Day 36-45: Project Development + Revision

 Java: Complete backend with Spring Boot (e.g., e-commerce or blog app).
 JavaScript: Build React frontend with full functionality.
 SQL: Implement complex database operations (e.g., joins, stored procedures).
 Git: Use Git for version control, manage multiple branches.
 DSA: Solve top 50 interview problems (Striver A2Z, LeetCode).
 Aptitude: Practice full mock tests.
 Practice (Daily):
o Java: Add one backend feature (e.g., user authentication).
o JavaScript: Build one frontend feature (e.g., user dashboard).
o SQL: Write 1-2 complex queries for the project.
o Git: Commit and push daily changes.
o DSA: Solve 5 problems daily (mix of arrays, trees, graphs, DP).
o Aptitude: Solve 10 mock test problems daily.
 Resources: Baeldung, React Official Docs, LeetCode, Striver A2Z, PrepInsta.
Week 8: Final Polishing + System Design + Interview Prep
Goal: Optimize projects, learn system design, and prepare for interviews.

Day 46-52: Polishing and Interview Prep

 Java: Optimize Spring Boot code (e.g., reduce API latency).

 JavaScript: Refactor React code for performance (e.g., memoization).
 SQL: Optimize database schema and queries.
 Git: Finalize project repository, write README.
 System Design: Learn basics (e.g., REST API design, database scaling).
 DSA: Solve advanced problems (e.g., sliding window, greedy algorithms).
 Aptitude: Full-length mock tests.
 Interview Prep: Practice behavioral questions, resume review, mock interviews.
 Practice (Daily):
o Java: Refactor one API endpoint.
o JavaScript: Optimize one React component.
o SQL: Optimize one query or schema.
o Git: Update project documentation.
o System Design: Study one design concept (e.g., load balancing).
o DSA: Solve 5 advanced problems daily.
o Aptitude: Solve 10-15 mock test problems.
o Interview: Practice 1-2 behavioral questions daily.
 Resources: Baeldung, React Official Docs, System Design Primer, LeetCode, PrepInsta,
InterviewBit.

Daily Practice Structure

 Coding: 3-5 DSA problems (Striver A2Z, LeetCode).
 Java: 1-2 tasks (e.g., implement a method, class, or feature).
 JavaScript: 1-2 tasks (e.g., build a component, handle events).
 SQL: 1-3 queries or schema design tasks.
 Aptitude: 5-10 problems based on the day’s topic.
 Git: Commit daily work; use branches for projects.

Recommended Resources
 Java: Oracle Java Docs, GeeksforGeeks, W3Schools, Tutorialspoint, Baeldung.
 JavaScript: W3Schools JavaScript, MDN Web Docs, React Official Docs.
 SQL: W3Schools SQL, Mode Analytics SQL Tutorial, SQLZoo.
 DSA: Striver A2Z Sheet, LeetCode, GeeksforGeeks, TakeUForward.
  Aptitude: IndiaBix, CareerRide, PrepInsta.
 Git: Git Official Docs, GitHub Guides, Atlassian Git Tutorials.
 Full Stack: Spring Boot Official Docs, React Official Docs, Baeldung.
 System Design: System Design Primer, Grokking the System Design Interview.
 Interview Prep: LeetCode Interview Questions, InterviewBit, Glassdoor.

Notes
 Consistency: Dedicate 4-6 hours daily, balancing theory, practice, and projects.
 Projects: Build at least two full-stack apps (e.g., Todo, E-commerce) to showcase skills.
 Version Control: Use Git from Day 13 and for all projects to manage code effectively.
 Interview Prep: Start mock interviews in Week 6 to build confidence.
 Progress Tracking: Maintain a log of solved problems and completed tasks.
 Community: Engage with forums like LeetCode Discuss, Stack Overflow, and Reddit
for support.

This roadmap ensures you cover all necessary skills for Java Full Stack development, DSA,
aptitude, JavaScript, SQL, and Git, preparing you for technical interviews and real-world
projects.