Complete 2-Year Roadmap: CGPA + GATE CSE + IIT

Based on your II Year–III Year [Link] CSE syllabus (SRGEC, R23-type structure)

Note on your syllabus file: It contains full detail for II Year (Sem I & II) and III Year (Sem I & II) only — no IV Year content was present in
the PDF. This roadmap covers what's in the file (II-1 through III-2) and extends logically into IV Year using standard GATE CSE requirements,
since that's where your GATE attempt will actually happen.
Target: GATE CSE February 2028 (primary attempt, right after III-2/early IV-1) with an optional stronger second attempt in GATE 2029 for IIT
[Link] admission if rank isn't IIT-worthy the first time. Both are planned below so you have a real safety net.
 PART 1 & 2 — Full Syllabus Analysis + GATE Mapping

Legend: HIGH Extremely Important for GATE IMPORTANT Important HELPFUL Helpful CGPA College-grade only

II Year – I Semester

GATE GATE
Subject What it teaches GATE Subject(s) it Feeds Prereq Difficulty
Importance Weightage

Discrete Mathematics & Logic, sets, relations, combinatorics, HIGH Engineering Mathematics (Discrete Basic set Medium ~8-10
Graph Theory recurrence relations, graph theory Math) theory marks

Digital Logic & Computer Boolean algebra, gates, sequential circuits, HIGH Digital Logic + Computer None Medium- ~13-15
Organization CPU architecture, memory, I/O Organization & Architecture High marks

Advanced Data Arrays, trees, heaps, hashing, graphs, HIGH Data Structures + Algorithms Basic High ~18-20
Structures & Algorithm algorithm design (DP, greedy, divide-conquer) programming marks
Analysis (single
biggest
chunk)

OOP through Java Classes, inheritance, polymorphism, HELPFUL Rarely tested directly; helps C basics Low- ~2-3 marks
exceptions, collections Programming section Medium

ADS & Algorithms Lab Implementation of DS/algorithms IMPORTANT Builds coding fluency for GATE- — Medium Indirect
adjacent interviews/PSU coding
rounds

OOP Java Lab Java implementation practice CGPA — — Low None

directly

Python Programming Syntax, data handling, scripting HELPFUL Not a GATE topic, but useful for None Low None
DA/ML electives & projects directly

Why DS/Algo and Digital Logic/COA are HIGH : these two areas alone make up roughly one-third of the entire GATE CSE paper every
year. Discrete Math is the largest chunk of the Engineering Mathematics section (13 marks total). Java and Python are CGPA/practical
subjects — good to know well for labs and projects, not directly GATE-tested.

II Year – II Semester

GATE GATE
Subject What it teaches GATE Subject(s) Prereq Difficulty
Importance Weightage

Managerial Economics & Costing, accounting, economics basics CGPA None None Low None
Financial Analysis

Probability & Statistics Probability, distributions, estimation, HIGH Engineering Mathematics Basic math Medium ~6-8 marks
hypothesis testing (Probability)

Operating Systems Processes, scheduling, memory HIGH Operating Systems C, basic Medium- ~13-15
management, deadlocks, file systems architecture High marks

Database Management ER modeling, relational algebra, SQL, HIGH Databases Discrete math Medium ~13-15
Systems normalization, transactions (relations) marks

Software Engineering SDLC, testing, project management HELPFUL Rarely tested; occasional 1-mark None Low ~0-2 marks
concepts conceptual question

Operating Systems Lab Shell scripting, system calls, process IMPORTANT Reinforces OS concepts practically OS theory Medium Indirect
programs

DBMS Lab SQL queries, schema design IMPORTANT Reinforces DBMS/SQL, huge for DBMS theory Medium Indirect
GATE numericals on queries

Full Stack Development – Web dev (frontend/backend basics) CGPA Not GATE-relevant, great for Java/Python Medium None
1 resume/projects

Design Thinking & Ideation, prototyping frameworks CGPA None None Low None
Innovation

Environmental Science Ecology, sustainability CGPA None None Low None

Why OS + DBMS are HIGH : together they're roughly 25-28 marks of GATE, and both build directly on II-1's Digital Logic/DS
foundation. Probability is the second-biggest Math sub-topic after Discrete Math. MEFA, Software Engineering, Full Stack-1, Design
Thinking, and Environmental Science are CGPA subjects — study them for grades, not depth.

III Year – I Semester

GATE
Subject What it teaches GATE Importance GATE Subject(s) Prereq Difficulty
Weightage

Data Warehousing & OLAP, mining algorithms, HELPFUL Not a core GATE paper topic; DBMS Medium ~0-2 marks
Data Mining clustering, classification occasional overlap with ML
elective

Computer Networks OSI/TCP-IP, routing, congestion HIGH Computer Networks OS Medium- ~10-12
control, application-layer protocols basics High marks

Formal Languages & Finite automata, regular languages, HIGH Theory of Computation Discrete High ~8-10
Automata Theory CFGs, Turing machines, decidability math (abstract) marks

Professional Elective I (choose Artificial Intelligence / HELPFUL – IMPORTANT (AI is AI overlaps with GATE DA (Data Varies Medium Depends on
OOAD / Distributed OS / Software IMPORTANT if choosing GATE DA Science & AI) paper, not core CS choice
Project Mgmt) overlap) paper

Open Elective I – Revisits core DS HIGH (free revision credit) Data Structures — Low Reinforces
Fundamentals of Data (revision) core
Structures

Ethical Hacking Security concepts, tools HELPFUL Minor overlap with Networks Medium ~0-1 marks
Cryptography/Network Security
GATE topics

Data Mining Lab Practical mining tool use CGPA — — Low None

Computer Networks Socket programming, protocol IMPORTANT Reinforces CN concepts CN Medium Indirect
Lab simulation theory

Soft Skills Communication, interview skills CGPA Useful for GATE interview/IIT None Low None
admission interactions, not exam

UI Design using Flutter Mobile app UI CGPA None None Low None

Honor's: Data Science Python data science stack HELPFUL Useful only if targeting GATE DA Python Medium Depends
+ Lab paper instead/in addition

Why CN + TOC are HIGH : Computer Networks is a full GATE subject on its own; Theory of Computation, despite being conceptually
the hardest for most students, is consistently tested and high-yield once mastered because question patterns repeat. Pick Professional
Elective I = Artificial Intelligence if there is any chance you'll also attempt GATE DA (Data Science & AI) — otherwise pick
based on genuine interest since none of the others move the GATE-CS needle much.

III Year – II Semester

GATE
Subject What it teaches GATE Importance GATE Subject(s) Prereq Difficulty
Weightage

Compiler Design Lexical analysis, parsing, code generation, IMPORTANT Compiler Design TOC High ~4-6 marks
optimization

Cloud Computing Virtualization, service models, cloud CGPA Not a GATE topic Networks/OS Low- None
architectures Medium

Cryptography & Encryption algorithms, protocols, security HELPFUL Minor overlap in CN paper CN, discrete Medium ~1-2 marks
Network Security mechanisms (security section) math

Professional Elective (Cyber Security / Software Testing / IMPORTANT if ML chosen Machine Learning maps to Probability, Medium- Depends
II DevOps / Machine Learning) (GATE DA overlap) GATE DA linear algebra High

Professional Elective (NLP / Big Data / Quantum Computing / HELPFUL Mostly non-core; NLP has Varies Medium Minor
III MANET) slight DA overlap

Open Elective II (Fundamentals of Java / Scripting CGPA None — Low None

Languages)

Cloud Computing Cloud tool practicals CGPA — — Low None

Lab

Cryptography Lab Security tool practicals CGPA — — Low None

Full Stack Advanced web dev CGPA Resume/project value only FSD-1 Medium None
Development – 2

Technical Paper Research writing, patents CGPA None None Low None
Writing & IPR

Honor's: Data Matplotlib/Seaborn/Plotly CGPA Portfolio value only Python Low None
Visualization + Lab

Why Compiler Design is IMPORTANT not HIGH : it's tested every year but usually only 2-3 questions total; still worth solid
understanding because TOC + Compiler together form a coherent "language theory" block that's efficient to study together. Everything
else in III-2 is CGPA/skill-building — good for placements and projects, not GATE score.
 PART 3 — Semester-Wise Study Strategy

Can Be Finished
Semester Study Deeply (GATE-critical) Good Semester Prep Only (CGPA) Needs Continuous Revision
Quickly

II-1 Digital Logic & COA, Advanced Data OOP Java, both labs DS & Algorithms (start immediately, never Python Programming
Structures & Algorithms, Discrete Math stop until GATE)

II-2 Operating Systems, DBMS, Probability & MEFA, Software Engg, FSD-1, Design OS + DBMS (weekly revision from now on) MEFA, Env. Science,
Statistics Thinking, Env. Science Design Thinking

III-1 Computer Networks, Formal Languages & Ethical Hacking, Soft Skills, Flutter UI, TOC, CN, plus continued revision of DS/Algo, DWDM, Flutter, Soft
Automata Theory DWDM OS, DBMS, Digital Logic Skills

III-2 Compiler Design (moderate depth) Cloud Computing, Crypto, FSD-2, Tech Everything from II-1 through III-1 (this is your Cloud Computing,
Paper Writing, Open Elective II first full GATE revision cycle) FSD-2, Electives
 PART 4 — Two-Year Month-by-Month Roadmap (July 2026 → Feb 2028, GATE 2028)

Ground rule for every month: college coursework always gets priority during exam weeks; GATE self-study runs in parallel every non-
exam week, never stops completely, and never exceeds roughly 40% of your total study time until III-2 (then it flips to 60%+).

Year 1 — II Year

College
Month GATE Priority Topics to Complete Revision PYQs Mock Tests Buffer
Priority

Jul Settle into II-1, Start Digital Logic + Discrete Boolean algebra, — (too early) — — 1 wk for
2026 attend all Math (Units I-II each) gates; orientation
classes Propositional/predicate
logic

Aug Internal-1 prep Digital Logic (combinational Continue both subjects Weekly self-quiz on prior — — —
2026 circuits), Discrete Math (Set unit-wise, alongside weeks
theory) class pace

Sep Internal-1 Light touch only during exam Pause new topics Revise Digital Logic Units Start topic-wise PYQs — 3-4 days
2026 exams week exam week; resume I-II for completed units post-exam
after buffer

Oct ADS&AA + Data Structures (arrays, linked Cover DS chapters in Weekly revision of Digital 15-20 PYQs on Digital — —
2026 labs pick up lists, stacks, queues, trees) sync with class Logic + Discrete Math Logic
pace

Nov Internal-2 + Reduce to revision-only Consolidate DS basics; Full revision of everything PYQ set for Discrete — 1 wk pre-
2026 End Sem prep no new GATE topics done since July Math exam
buffer

Dec End semester Pause new GATE content during — Post-exam: 1 week full Mixed PYQ set (Digital First mini self-test 1-2 wks
2026 exams (II-1) exam block revision of II-1 GATE- Logic + Discrete Math (30 Qs, no time winter
relevant subjects + basic DS) pressure) buffer

Jan II-2 begins: OS, Algorithms (sorting, searching, Algorithm design Weekly revision cycle PYQs on DS — —
2027 DBMS, Prob & greedy, DP basics) paradigms begins (see Part 9)
Stats

Feb OS/DBMS Algorithms (graph algorithms, Finish Algorithms unit Revise DS + Digital Logic PYQs on Algorithms — —
2027 coursework complexity analysis)
pace-matching

Mar Internal-1 (II-2) Operating Systems (processes, OS theory ahead Revise Discrete Math + PYQs on OS (as — —
2027 prep scheduling) — dual-purpose with of/with class Algorithms covered)
coursework

Apr Internal-2 + Probability & Statistics (dual- Finish Probability Consolidate Math PYQ set: Math Mini self-test #2 1 wk
2027 End Sem prep purpose) (Discrete + Probability) (60 Qs) buffer

May End semester Pause — Post-exam full revision: Mixed PYQ set — 2 wk
2027 exams (II-2) OS, Math, DS, Algo, summer
Digital Logic buffer

Jun Vacation DBMS (deep dive, this is ER model, SQL, Revise OS PYQs: DBMS Mock Test #1 Recovery
2027 vacation-priority) normalization, (half-length, 65 days after
transactions Qs, timed) mock

Year 2 — III Year (Heaviest GATE phase)

Topics to
Month College Priority GATE Priority Revision PYQs Mock Tests Buffer
Complete

Jul III-1 begins: CN, Computer Networks (dual-purpose with OSI/TCP-IP layers, Weekly PYQs: DBMS + CN — —
2027 TOC coursework) routing revision cycle
continues

Aug Internal-1 prep Theory of Computation (dual-purpose) Finite automata, Revise PYQs: TOC — —
2027 regular languages Algorithms +
OS

Sep Internal-1 exams Pause new topics during exam week — Post-exam — — 3-4 days
2027 revision block

Oct ADS-level TOC (CFGs, Turing machines) + CN Finish both Revise DBMS PYQs: mixed CN+TOC Mock Test #2 (full- —
2027 coursework (transport/app layer) subjects + CN so far length, 65 Qs, 3
tapering hrs)

Nov Internal-2 + End Compiler Design (lexical/parsing basics Light intro, don't Full revision: Large mixed PYQ set — 1 wk pre-exam
2027 Sem prep only) go deep yet everything so (all subjects to date)
far

Dec End semester Pause — Post-exam — Mock Test #3 1-2 wk winter

2027 exams (III-1) revision (1 wk) buffer

Jan III-2 begins: Full syllabus revision round 1 Revisit every Daily targeted Full PYQ paper-wise Mock Test #4 —
2028 Compiler Design begins GATE subject in 2- revision (see sets (last 10 years,
coursework day blocks Part 9) subject-wise)

Feb III-2 coursework GATE 2028 exam window — final Formula sheets, Daily quick- Previous 3-5 years' full 2-3 full mock 3 days total
2028 continues lightly revision only, no new topics from ~10 error log review recall revision papers, timed papers in exam-like rest right
 days before only conditions before exam

If your GATE 2028 rank isn't strong enough for a top IIT: you have III-2 (Feb-May 2028) + all of IV-1 (Jul-Dec 2028) available as a
second full run at GATE 2029, this time with every subject already covered once and only requiring revision + advanced problem-solving
— a much lighter load. See Part 11.
 PART 5 — Weekly Timetables

During College (Mon-Fri) — non-exam weeks

Time Activity

6:00-6:45 AM Exercise

7:00-9:00 AM College classes begin (per timetable)

Class hours College (labs/lectures)

Evening 6:00-7:00 PM Rest/dinner

7:00-9:00 PM GATE self-study (1 core subject, deep)

9:00-9:30 PM Daily revision (see Part 9)

10:30 PM Sleep (7-7.5 hrs minimum)

Saturday
Morning: catch up on any pending lab records/assignments (CGPA maintenance)
Afternoon: 3-hour GATE deep-study block (new topic or problem-solving)
Evening: PYQ practice (1 hour, topic-wise)

Sunday
Morning: Weekly revision (all topics touched that week) — 2 hours
Afternoon: Rest / hobby / social time — protect this, don't skip
Evening: Light planning for the coming week (30 min) + earlier sleep

During Semester Exams

80% time: college exam subjects
20% time (30-45 min/day): GATE maintenance revision only — flashcards/formula sheets, zero new topics
Sleep protected at 7 hrs even during exams — sleep debt hurts both CGPA and GATE retention

During Vacations
No college, so GATE gets 5-6 hrs/day in two blocks (morning deep-study, evening PYQs)
1 full day off per week, non-negotiable
Exercise daily (this is when it's easiest to build the habit)

During GATE Revision Months (Jan-Feb 2028)

6-7 hrs/day: 3 hrs revision, 2 hrs mock/PYQ, 1-2 hrs error-log review
Sleep protected even more strictly — no all-nighters before mocks or the real exam
1 half-day off per week to prevent burnout at the highest-stakes moment
 PART 6 — GATE Subject Priority Ranking (Highest → Lowest)

1. Data Structures & Algorithms — largest single scoring block, foundation for everything else
2. Operating Systems — high weightage, moderate difficulty, very learnable
3. Digital Logic & Computer Organization — high weightage, mostly formula/pattern-based, efficient to master
4. Database Management Systems — high weightage, SQL/normalization numericals are scoring
5. Computer Networks — solid weightage, mostly conceptual + a few numericals (subnetting, etc.)
6. Discrete Mathematics — largest Math sub-section, needed early since it underlies graphs/relations
7. Theory of Computation — moderate weightage but high difficulty; strong ROI once mastered because question types repeat
8. Probability & Statistics — second Math sub-section, fewer but steady marks
9. Compiler Design — smaller weightage, but overlaps conceptually with TOC so cheap to add
10. Aptitude & Reasoning (General) — not from your syllabus at all, but is 15 marks of every GATE paper — you must self-add this (see
Part 12)

(Everything else in your syllabus — Software Engineering, Cloud Computing, Cryptography depth, Full Stack, Design Thinking, MEFA,
Environmental Science, Soft Skills, Flutter — is CGPA/placement value, not GATE-CS value, and is intentionally excluded from this
ranking.)
 PART 7 — Deep Study Strategy Per GATE Subject

General method for every subject below: Concept video/notes → solve solved examples yourself before checking → topic-wise PYQs →
error log → spaced revision. Never move to the next chapter with an open "I sort of understand this" — that's exactly the perfectionism
trap to avoid, so the bar is "I can solve a medium PYQ on this without help," not "I can explain it to a professor."
Data Structures & Algorithms: Order — arrays/strings → linked lists → stacks/queues → trees/BSTs → heaps → hashing → graphs →
sorting → greedy → DP → complexity analysis. Common mistake: memorizing code instead of tracing execution by hand. Practice: 15-
20 problems per topic. Revision: weekly recall of time/space complexities. Mastery sign: you can derive recurrence relations for
algorithm complexity without looking them up.
Operating Systems: Order — processes/threads → CPU scheduling → synchronization (semaphores, deadlock) → memory
management (paging, segmentation) → virtual memory → file systems → disk scheduling. Common mistake: confusing scheduling
algorithm numericals under time pressure. Practice: 10-15 numericals per topic (scheduling, page replacement especially). Mastery
sign: you can solve a new scheduling numerical variant, not just a memorized one.
Digital Logic & COA: Order — number systems → Boolean algebra/K-maps → combinational circuits → sequential circuits →
CPU/instruction cycle → pipelining → memory hierarchy/cache → I/O. Common mistake: sign errors in number system conversions.
Practice: heavy K-map and pipelining numerical practice. Mastery sign: cache/pipeline numericals solved within 3 minutes.
DBMS: Order — ER model → relational model → SQL → normalization (1NF-BCNF) → transactions/ACID → concurrency control →
indexing. Common mistake: rushing normalization without checking all functional dependencies. Practice: 20+ SQL query problems,
15+ normalization problems. Mastery sign: given a random relation + FDs, you find the correct normal form in under 5 minutes.
Computer Networks: Order — OSI/TCP-IP models → data link layer → network layer (routing, subnetting) → transport layer
(TCP/UDP, congestion control) → application layer. Common mistake: subnetting arithmetic errors. Practice: heavy subnetting drills,
routing algorithm traces. Mastery sign: subnetting problems solved without a calculator.
Discrete Mathematics: Order — propositional/predicate logic → set theory/relations/functions → combinatorics → graph theory →
recurrence relations. Common mistake: sign/counting errors in combinatorics. Practice: 15+ problems per sub-topic. Mastery sign:
correctly identifying which counting technique (permutation vs combination vs inclusion-exclusion) applies without hesitation.
Theory of Computation: Order — finite automata → regular expressions/languages → context-free grammars → pushdown automata
→ Turing machines → decidability. Common mistake: over-thinking — TOC questions usually test one clean idea per question, not
deep theory. Practice: 10-12 problems per topic, focus on construction problems. Mastery sign: you can construct a DFA/CFG for a
new language description within 5 minutes.
Compiler Design: Order — lexical analysis → parsing (top-down, bottom-up) → syntax-directed translation → code optimization
basics. Common mistake: confusing LL vs LR parsing table construction. Practice: 8-10 problems, mainly parsing table construction.
Mastery sign: build a parsing table for a new grammar without reference notes.
Probability & Statistics: Order — basic probability → conditional probability/Bayes → random variables/distributions →
expectation/variance → estimation basics. Common mistake: misapplying Bayes' theorem setup. Practice: 15+ problems, heavy on
conditional probability. Mastery sign: correctly set up a Bayes' problem from a word problem without confusion.
PART 8 — PYQ Strategy

Start PYQs as soon as you finish your first full chapter/unit of any subject — don't wait for the whole subject to be done.
Volume per chapter: 10-15 PYQs immediately after each chapter; a full 300+ question topic-wise PYQ bank once the whole subject
is complete.
Mistake analysis: maintain one running error log (spreadsheet or notebook) with columns — Question | Subject | Mistake Type
(concept gap / silly error / time pressure) | Correct Approach. Review this log every Sunday.
Revisions before moving ahead: minimum 2 full revisions of a chapter's PYQs before moving to the next chapter — first pass right
after learning, second pass 7-10 days later (spaced repetition). A third pass happens automatically during your monthly/semester
revision cycles.
PART 9 — Revision System

Daily (15-20 min): quick recall of yesterday's topic — no notes, active recall only.
Weekly (Sunday, 2 hrs): revise everything touched that week + redo 5-10 previously-wrong PYQs from the error log.
Monthly (last weekend of month, half day): full revision of the month's 1-2 subjects + a small timed quiz (20-30 Qs).
Semester (during end-sem exam prep + right after, ~1 week): consolidate every GATE subject covered that semester into a one-
page formula/summary sheet per subject.
Final GATE Revision (Jan-Feb 2028): rotate through all subjects in 2-day blocks using only your accumulated summary sheets and
error log — no fresh reading of textbooks at this stage.
PART 10 — CGPA Strategy

Minimum effort for strong CGPA (8.5+): attend classes (many R23-pattern colleges weight internal marks heavily on attendance
+ assignments), complete every lab record and assignment on time — these are close to guaranteed marks — and for external exams,
focus revision on previous 3-4 years' university question papers rather than the entire textbook.
Subjects needing extra CGPA attention: the "GATE-irrelevant" subjects (MEFA, Software Engineering, Environmental Science,
Cloud Computing, Design Thinking, Cryptography, Full Stack, electives) — because you won't be studying them deeply for GATE, so
all your marks there must come from disciplined semester-exam prep, not accumulated GATE knowledge.
Smart exam technique: for university exams, past-paper pattern recognition matters more than depth — professors often repeat
question structures. 4-5 previous papers solved is usually enough for 8+ CGPA in a subject, even without mastery.
Protecting GATE prep during exams: treat each end-semester exam block as a planned 2-3 week GATE-pause (matches the buffer
weeks already built into Part 4) rather than trying to do both simultaneously — this prevents the common failure mode of doing both
badly.
PART 11 — IIT Strategy

Target score/rank: top IITs (Bombay, Delhi, Madras, Kanpur, Kharagpur) for CSE [Link] typically need a GATE CS rank roughly in
the low hundreds to ~1000-1500 depending on category and specific IIT/specialization; a safer general-category target is top 500-
800 all-India rank, which usually means a raw score comfortably above the qualifying cutoff — treat 85th+ percentile-level
performance on full-length mocks as your internal benchmark closer to the exam.
Realistic timeline: first attempt Feb 2028 (right after this roadmap); if the rank isn't IIT-worthy, a second attempt Feb 2029 with
lighter prep load (pure revision + advanced problem-solving, since first pass is already done) is a completely normal and common
path — many successful IIT GATE candidates are second-attempters.
Common reasons students fail: starting serious prep too late (you're avoiding this by starting now), over-focusing on low-
weightage subjects out of comfort, skipping PYQ analysis, no formal mock-test discipline, and burnout from an unsustainable daily
schedule.
Avoiding burnout: the weekly timetable above deliberately protects sleep and one rest day — treat these as fixed constraints, not
flexible ones. A tired brain retains less per hour than a rested one studying less.
Staying consistent for 2 years: anchor to the weekly rhythm, not daily willpower — the Sunday revision + monthly quiz checkpoints
in Part 9 give you built-in accountability without needing constant motivation.
 PART 12 — Resources Per GATE Subject

Subject Textbook Free YouTube Practice Book PYQ Source Mock Tests

Data Cormen (CLRS) for depth, Narasimha Karumanchi for Abdul Bari Karumanchi's "Data GATE Overflow (topic- GATE Overflow test
Structures & GATE-focused practice (algorithms), Gate Structures and Algorithmic wise), made easy PYQ series, NPTEL
Algorithms Smashers (DS) Thinking" books assignments

Operating Galvin's "Operating System Concepts" Gate Smashers, Made Easy OS workbook GATE Overflow Made Easy / Ace
Systems Neso Academy Academy test series

Digital Logic Morris Mano's "Digital Design" + "Computer System Neso Academy (both Made Easy COA workbook GATE Overflow Made Easy test series
& COA Architecture" playlists are
excellent)

DBMS Korth's "Database System Concepts" Gate Smashers Made Easy DBMS workbook GATE Overflow Made Easy / Testbook

Computer Forouzan's "Data Communications and Networking" Gate Smashers Made Easy CN workbook GATE Overflow Made Easy test series
Networks

Discrete Rosen's "Discrete Mathematics and Its Applications" Gate Smashers Made Easy Engineering GATE Overflow Made Easy test series
Mathematics (already a reference in your syllabus) (Discrete Math Math workbook
playlist)

Theory of Ullman's "Introduction to Automata Theory, Neso Academy TOC Made Easy TOC workbook GATE Overflow Made Easy test series
Computation Languages, and Computation" playlist

Compiler Ullman's "Compilers: Principles, Techniques, and Neso Academy Made Easy Compiler GATE Overflow Included in full-length
Design Tools" (Dragon Book, for reference only — don't go workbook (short) mocks
too deep)

Probability & Any standard engineering probability text Gate Smashers Made Easy Engineering GATE Overflow Made Easy test series
Statistics Math workbook

Aptitude & R.S. Aggarwal (quantitative + verbal) Any standard R.S. Aggarwal practice sets GATE Overflow general Included in every full-
Reasoning aptitude channel aptitude section length mock

Full-length mock series (subject-agnostic): GATE Overflow (free, community-driven, closest to real difficulty), Made Easy test series,
Ace Academy test series — pick one primary series and stick with it rather than switching mid-way.
 PART 13 — Final Output

1. One-Page Roadmap

NOW (Jul 2026) ──► II-1: Digital Logic + Discrete Math + start DS
──► II-2: DS+Algo continue, OS, Probability, DBMS starts
──► Summer '27: DBMS deep dive + Mock Test #1
──► III-1: Computer Networks + TOC, Compiler intro
──► III-2 (Jan '28): Full revision round + Mocks 2-4
GATE 2028 (Feb) ──► If rank strong: IIT admission process begins
──► If not: revision-only prep continues through
III-2/IV-1 for GATE 2029 (stronger attempt)

2. Month-Wise Checklist
Use the Part 4 tables directly as your checklist — one row per month, tick off "Topics," "Revision," "PYQs," "Mock Test" columns as
completed.

3. Semester-Wise Checklist
[ ] II-1: Digital Logic done + revised, Discrete Math done + revised, DS started, CGPA subjects passed 8.5+
[ ] II-2: DS+Algo complete, OS complete, Probability complete, DBMS started, CGPA subjects passed 8.5+
[ ] III-1: DBMS complete, CN complete, TOC complete, 1 mock test done, CGPA subjects passed 8.5+
[ ] III-2: Compiler Design complete, full syllabus revision round 1 done, 3+ mock tests done, GATE 2028 attempted

4. GATE Preparation Checklist

[ ] All 9 core subjects covered at least once by Jan 2028
[ ] Error log actively maintained since first PYQ set
[ ] Minimum 4 full-length mock tests completed before the real exam
[ ] One-page summary sheet exists for every subject
[ ] Aptitude & Reasoning practiced weekly throughout (don't leave this to the end)

5. CGPA Checklist
[ ] Attendance maintained every semester
[ ] All lab records/assignments submitted on time, every semester
[ ] 3-4 previous university papers solved before every end-sem exam
[ ] No semester below 8.5 CGPA target

6. Printable Action Plan

Print Part 4's two tables + Part 5's weekly timetable + Part 9's revision system — these four blocks are literally all you need pinned
above your desk.

7. Risk Analysis — Falling Behind

Delay Impact Recovery Plan

1 Minor — one topic/unit pushed Absorb using the built-in buffer weeks in Part 4; skip one planned mock-test's "extra" review round, don't skip the mock itself
month
behind

3 Moderate — a full subject at risk Drop Compiler Design to bare-minimum PYQ-pattern coverage (it's rank #9 for a reason); reclaim time from CGPA-only
months of being rushed subjects by using only past-paper-pattern prep (Part 10); extend vacations' GATE hours from 5-6 to 7-8
behind

6 Major — GATE 2028 becomes Explicitly shift primary target to GATE 2029 now (not later, to avoid panic-cramming); use the "extra" year to go deeper rather
months unrealistic for a strong IIT-level than faster — this often produces a better rank than a rushed 2028 attempt, so it's a real strategy, not just a fallback
behind rank

The single biggest risk-reducer in this whole plan: the weekly Sunday revision (Part 9) and monthly quizzes are what catch small
drift before it becomes a 3- or 6-month problem — treat missing two Sundays in a row as your trigger to stop and recalibrate, not push
through.