A semester-by-semester roadmap from Day 1 of Semester 1 to final placement, built for Indian engineering students, especially at tier-2/tier-3 colleges with limited guidance.
Every resource is free-first and verified active. All 8 semesters are shown below on one page, so whichever year you're in, jump straight to what's relevant to you. All 8 semesters are fully built, from Semester 1 foundations to Semester 8 offer conversion.
Semester 1 is about survival and building the right habits, not results. Don't panic if you feel behind everyone else already talking about DSA and internships, that's genuinely 3-4 semesters away for most people, and rushing it now usually just burns you out before it matters.
Clear, exam-focused explanations that map directly to what universities actually ask, not abstract theory-heavy content.
Free to audit (₹1000 only if you want the certificate). Straight from IIT faculty if you want more rigor than your college lectures.
A genuinely complete beginner-to-solid-fundamentals C course with notes, a PDF handbook, and two hands-on projects, the lab is just this same syllabus, typed and run yourself.
Structured practice from absolute basics (variables, I/O) through functions and recursion.
Get comfortable writing and reading code without panicking. Don't touch competitive programming or DSA yet, that's Semester 3-4. Right now the goal is fluency with loops, conditionals, functions, arrays, and basic problem decomposition.
Your primary structured course for the semester.
Over 100 worked examples across patterns, arrays, strings, and number problems for building pattern recognition.
A judge-based platform to actually submit and test code, useful once you are past pure tutorial-following.
Takes two numbers and an operator, handles basic error cases like division by zero.
Uses random number generation and a loop with hint feedback ("too high" / "too low"). Good practice for loops, conditionals, and I/O.
Takes marks in multiple subjects, computes total, percentage, and grade using conditionals, reinforcing arrays/lists from your coursework.
| Programming practice (beyond class/lab) | 4-5 hrs |
| Academic subject revision (all subjects combined) | 3-4 hrs |
| Club/community involvement | 1-2 hrs |
Semester 2 is where you move from 'I can write a loop' to actually thinking in objects. Object-Oriented Programming (usually C++ or Java, depending on your university) is the real focus, everything from your Semester 3 DSA course to real-world software design assumes you're comfortable with classes, objects, and the four OOP pillars by the time this semester ends.
Same channel as Semester 1, consistent teaching style, covers the standard Math II topics most Indian universities follow.
Free to audit. Useful if your university leans probability/statistics rather than differential equations this semester.
A full, beginner-friendly C++ and OOP course with real-time coding, the natural next step after Semester 1 C.
A 12+ hour beginner Java course covering fundamentals through OOP (classes, inheritance, polymorphism), if your university teaches Java instead of C++.
Structured practice specifically on classes, objects, and OOP concepts, not just general C++ syntax.
Get genuinely fluent in classes, objects, constructors, inheritance, encapsulation, and polymorphism, not just able to define them if asked. This is the foundation nearly everything after this semester builds on: your DSA course next semester, real-world project structure, and a huge share of interview questions for the next several years.
Your primary structured course for the semester if your university uses C++.
Same role as the CodeWithHarry playlist, but for Java-first universities.
Keep submitting and testing code on a real judge, not just following along with tutorials.
Classes for Book and Member, with add/issue/return operations. Directly practices encapsulation and basic class design.
A class with deposit, withdraw, and balance-check methods, plus basic validation (no overdrawing). Good practice for encapsulation and simple error handling.
2D array for the board, functions for win-checking and turn logic. Reinforces arrays, functions, and basic game-loop thinking before you touch anything more advanced.
| OOP / programming practice (beyond class/lab) | 5-6 hrs |
| Academic subject revision (all subjects combined) | 3-4 hrs |
| Project building | 2-3 hrs |
| Club/community involvement | 1-2 hrs |
Semester 3 is where the real interview-prep clock starts ticking. Data Structures & Algorithms stops being a theory subject and becomes a daily habit, arrays, strings, linked lists, and stacks/queues, in that order. Don't jump between topics or sheets, pick one structured sheet and go through it in sequence. This is also usually the semester DBMS and Computer Organization enter your syllabus, both of which come back constantly in interviews later.
The same playlist from your Semester 2 DS theory intro, now the concept explanations you use alongside actual problem-solving.
A free, structured ~450-problem sheet with video explanations, organized topic by topic in the exact order you need: arrays, strings, linked lists, then stacks/queues.
Covers sets, relations, functions, propositional logic, and graph theory, mapped closely to what most university exams and GATE actually ask.
A single-sitting video walkthrough if you prefer watching over reading, useful right before exams too.
Pick ONE structured sheet and follow its order, don't hop between Striver's, Love Babbar's, and random YouTube videos, that's how most people burn 3 semesters without actually getting good. Go arrays first, then strings, then linked lists, then stacks/queues. The goal by semester-end isn't finishing every hard problem, it's being unable to be surprised by a basic array/string/linked-list/stack question in an interview.
Your primary ordered path for the semester, arrays and sorting first, then strings, linked lists, and stacks/queues, each with video solutions.
Use this for the 'why does this work' conceptual explanation whenever the sheet's video solution moves too fast.
Nearly 100 linked-list-only problems, filterable by difficulty, for extra reps once you finish the linked list section of your main sheet.
A focused, interview-weighted set for the stacks/queues section, the last stop of DSA Phase 1.
A free, guided LeetCode card that builds up queue and stack intuition with monotonic stacks and deque patterns, useful once the basics feel solid.
Implement insert, delete, search, and reverse yourself, no built-in list/vector classes. Directly cements the linked list section of your DSA sheet instead of just solving isolated problems.
A console text editor that supports typing, undo, and redo using two stacks. A genuinely real-world stack application, not just an abstract exercise.
Simulate a real FIFO system (ticket counter or print queue) using your own queue implementation, not a built-in one. Reinforces the queue half of this semester’s skill focus.
| DSA practice (arrays/strings/linked lists/stacks/queues) | 10-12 hrs |
| Academic subject revision (all subjects combined) | 4-5 hrs |
| Project building | 2 hrs |
| Club/community involvement | 1-2 hrs |
Semester 4 is where DSA gets genuinely harder, recursion/backtracking, trees, graphs, and dynamic programming, and where the classic CS-core subjects (OS, Computer Networks) start piling on. It feels heavier because it is, but this is also the exact syllabus that shows up in almost every technical interview from Semester 6 onward, so the effort compounds directly.
Continue on the same sheet you started in Semester 3, don't restart on a new one. This phase is where most people plateau, trees and graphs feel abstract until you've drawn enough of them by hand, and DP genuinely needs repetition before it clicks. Budget more time for DP than any other topic this semester, it's the single most interview-decisive DSA topic from here through placements.
Keep following the same sheet from Semester 3, now into recursion, trees, graphs, and DP sections.
A focused, ordered path through binary trees, BSTs, and tree traversals, with video solutions for each problem.
Covers BFS/DFS, shortest paths, MSTs, and topological sort in a structured order, the single most-used resource for graph interview prep.
Teaches every DP problem as recursion → memoization → tabulation → space optimization, the approach that actually builds real DP intuition instead of memorized patterns.
Keep using this for conceptual explanations whenever a topic (especially DP or graphs) needs a slower, from-scratch walkthrough.
Implement insert, delete, search, and in-order/pre-order/post-order traversal from scratch, then print the tree structure to console. Cements the tree section of your DSA sheet.
Model locations as graph nodes and implement Dijkstra's algorithm to find the shortest route between two points. A genuinely practical application of the graph section.
A classic, well-scoped backtracking problem that reinforces recursion and constraint-checking before you move deeper into DP.
| DSA practice (recursion/trees/graphs/DP) | 12-14 hrs |
| Academic subject revision (all subjects combined) | 4-5 hrs |
| Project building | 2 hrs |
| Internship platform setup / early exploration | 1 hr |
| Git practice + Codeforces/competitive rounds | 1 hr |
Semester 5 is a genuine turning point: your DSA base is solid, and now it's time to build actual things and start applying for internships for real. Pick ONE development track (full-stack web is the most common and most beginner-friendly, but app dev or ML are valid too) and go deep instead of shallow-exploring five different stacks.
Don't try to learn web dev, app dev, and ML all at once, pick one based on what genuinely interests you (or what your target companies hire for) and build 2-3 real projects in it this semester. In parallel, treat internship applications as a weekly habit, not a one-time event, apply consistently on Internshala, Unstop, and LinkedIn rather than in occasional bursts. Also start getting comfortable with an AI coding assistant (GitHub Copilot, Cursor, or similar), using one well, reviewing what it suggests instead of blindly accepting it, is a genuinely expected skill in 2026 hiring, not a shortcut you need to hide.
A complete beginner-to-advanced MongoDB, Express, React, Node course with projects, the most common development track for CSE students.
Containers show up constantly from internships onward, this is the most-recommended free, beginner-friendly Docker course, taught by an actual Docker Captain.
The largest dedicated internship listing platform in India, lists tens of thousands of active internships including remote/WFH roles.
Internships, hackathons, and hiring challenges in one place, a good way to also build a visible resume of competitions alongside internship applications.
Best for premium/brand-name internship postings and for building the network that quietly matters a lot by placement season.
AI-matched job and internship search based on your own resume and profile, useful to run alongside Internshala/Unstop/LinkedIn rather than instead of them.
A clear, practical walkthrough of finding a project, understanding its contributing guidelines, and opening your first pull request.
User auth, CRUD posts, and a real database, your first genuinely complete full-stack project. Deploy it live (Vercel/Render free tiers) instead of leaving it local-only.
Build and document a standalone API (JWT auth, protected routes, proper status codes). A strong, resume-worthy artifact even without a frontend attached.
| Development track learning + building | 10-12 hrs |
| DSA maintenance practice (don’t fully stop) | 4-5 hrs |
| Internship applications + resume/LinkedIn work | 2-3 hrs |
| Academic subject revision | 3 hrs |
Semester 6 is about depth over breadth: one genuinely strong, deployed, well-documented project beats five half-finished ones. This is also usually when internship interview rounds intensify, and a good number of students convert their internship into a pre-placement offer (PPO), so treat every internship interview like it could shape your final placement.
Build the one project you would be genuinely excited to talk about for 20 minutes in an interview, real users or realistic scope, a proper database, authentication, and deployment. Add a basic CI/CD pipeline (tests + auto-deploy on push) and containerize it with Docker if your stack supports it, these two additions alone put your project ahead of most "just a tutorial clone" submissions. In parallel, don't apply to just 5-10 internships and wait, apply broadly and continuously, interviews are a numbers game as much as a skill one at this stage.
The official, free way to auto-run tests and deploy on every push, genuinely useful on your capstone project and a common practical interview/internship expectation now.
Start Low-Level Design (OOP design patterns like Singleton, Factory, Observer) now, it builds directly on your Semester 2 OOP and sets up the High-Level Design work in Semester 7-8.
Free Copilot, JetBrains IDEs, cloud credits (DigitalOcean/Azure), and domains, genuinely useful for actually deploying and hosting your capstone project properly.
Deploy your project live, a working link in your resume and LinkedIn beats a GitHub repo nobody will clone and run locally.
Keep applying here alongside Internshala and LinkedIn, hackathon wins from this semester also strengthen your resume directly.
Upload your resume and the internship job description to get an ATS-optimized cover letter in minutes, useful once you are applying broadly rather than to just one or two roles.
Pick a real problem (even a small one) and build it properly: auth, database, error handling, and a deployed, working link. This becomes the centerpiece of your resume and interview stories for the rest of placements.
Now that you made your first PR in Semester 5, go a level deeper: fix an actual bug or add a small feature. A merged, non-trivial PR is a genuinely strong, specific interview story, "tell me about a challenging bug" answers itself.
| Capstone project building + deployment | 10-12 hrs |
| DSA maintenance practice | 4-5 hrs |
| Internship applications | 2-3 hrs |
| Academic subject revision | 3 hrs |
| Docker/CI-CD practice + open-source contribution | 2 hrs |
Semester 7 is full placement mode. On-campus drives typically start this semester at most Indian colleges, so this is where every semester of DSA, projects, and CS-core revision gets tested for real. The goal now isn't learning new things, it's sharpening and rehearsing what you already know until it's fast and reliable under interview pressure.
This semester is about rehearsal, not new learning. Revise your DSA sheet by topic (don't re-solve everything, re-read your own past solutions and re-attempt the ones you struggled with), grind company-tagged questions for your target companies, do timed aptitude practice weekly, and get as many mock interviews in as you can, even peer-to-peer ones with classmates count.
Free, company-tagged interview questions and experiences, useful for targeted revision once you know which companies are visiting your campus.
Go back through the same sheet you've been using since Semester 3, this time as a timed revision pass, not first-time learning.
Most on-campus drives start with an aptitude round, weekly timed practice here keeps you fast, not just accurate.
Free peer-to-peer mock interviews (a limited number of credits per month on the free tier), genuinely useful for practicing explaining your thinking out loud under time pressure.
Scores your Resume Strength, LinkedIn Profile, Online Presence, and Role Alignment in one place, a fast way to see exactly where your profile is still weak this placement season.
Free, structured mock test tracks (FAANG Prep, DSA Mastery, Backend Path, and more) to pair with Pramp’s peer interviews for timed, topic-wise practice.
Now go from the Low-Level Design you started in Semester 6 into High-Level Design (load balancing, caching, database scaling), product-based companies increasingly ask at least one HLD-flavored question even at fresher level.
| DSA revision (company-tagged + sheet re-pass) | 8-10 hrs |
| Aptitude + GD/HR prep | 3-4 hrs |
| Mock interviews | 2-3 hrs |
| Applications (on-campus + off-campus) | 2 hrs |
Semester 8 has two very different tracks depending on where you stand: if you already have an offer, this semester is about finishing your major project, staying sharp for any remaining interviews, and preparing for what your actual job will need on Day 1. If you're still interviewing, off-campus and pool-campus drives continue well into this semester, don't lose momentum just because it's final semester.
If you have an offer: don't stop learning, use this lighter-workload semester to go deeper into your specific job role (SQL and system design if backend, DSA-in-your-actual-stack if product-based, cloud/DevOps basics if you know your team uses them). If you're still interviewing: keep applying off-campus and through pool drives, plenty of students place in this exact window, don't treat it as a lost cause.
Keep this bookmarked for any last-mile interview rounds, structured by both product-based and service-based company patterns.
If your incoming role is backend/full-stack, keep sharpening the LLD/HLD fluency you built in Semester 6-7, genuinely useful before Day 1, not just for interviews.
Claim this before you graduate and lose student status, free Copilot, JetBrains, and cloud credits are worth using while you still can.
If you are still interviewing, a fast, ATS-optimized cover letter per role for these last-mile off-campus and pool-campus applications.
| Major project completion + documentation | 4-5 hrs |
| Role-specific upskilling (or continued interview prep) | 4-5 hrs |
| Applications (if still interviewing) | 2 hrs |