Chapter 16: The 6-Month Battle Plan

The average successful candidate at ₹80L+ spends 4.7 months preparing. The average unsuccessful candidate spends 11 months — because they prepare without a system.

Read that again.

The difference between cracking a ₹1 crore offer and burning out after a year of scattered LeetCode grinding is not talent. It is not luck. It is not "which IIT you went to." It is a system. A plan that tells you exactly what to do on Tuesday at 7 PM when you are tired, demotivated, and wondering if any of this is worth it.

You have felt this. You open LeetCode, scroll through the problem list, pick something that looks doable, solve it in 45 minutes, feel a small dopamine hit, and close the tab. The next day you repeat the process. After three months, you have solved 90 problems but cannot explain how Dijkstra's algorithm works under pressure. You have watched 40 system design videos but cannot whiteboard a URL shortener end-to-end. You have "prepared" for 11 months and have nothing to show for it except a LeetCode streak and a vague sense that you are not ready.

This chapter is the antidote. It is a 26-week, day-by-day system that takes you from "I should probably start preparing" to "I have three competing offers and one of them is ₹95 lakh."

No fluff. No motivation posters. A battle plan.

The Architecture of the Plan

Before we dive into weeks, understand the three principles this plan is built on.

Principle 1: Progressive Overload. You do not start with system design interviews. You do not start with 5 LeetCode problems a day. Month 1 is embarrassingly basic — and that is the point. Each month builds on the last. By Month 5, you are doing things that would have broken you in Month 1. This is not a bug. It is the design.

Principle 2: Interleaving, Not Blocking. Most candidates do one month of DSA, then one month of system design, then one month of behavioral prep. This is a mistake. By the time you reach behavioral prep, your DSA is rusty. This plan interleaves topics: you touch DSA, system design, and behavioral prep every week from Month 3 onward. The intensity shifts, but nothing goes cold.

Principle 3: The Interview Is the Practice. You do not "get ready" and then interview. You interview to get ready. Starting Month 4, you are doing mock interviews every week. Starting Month 5, you are doing real interviews at companies you do not care about, so that by the time you interview at companies you do care about, you have already made all your mistakes.

Here is the full arc at a glance:

Month	Focus	DSA Load	System Design	Interviews
1	Foundation	2 problems/day	Fundamentals	None
2	DSA Deepening	3 problems/day	Case studies begin	None
3	System Design + Cloud	2 problems/day	Heavy	1 mock/week
4	AI/Agents + Mocks	1 problem/day	Review	2 mocks/week
5	Interview Gauntlet	Maintenance	Maintenance	3-4 real/week
6	Offer Optimization	None	None	Negotiation

Now let us break down each month, week by week.

---

Month 1: Foundation (Weeks 1-4)

Goal: Build the DSA core. Establish the daily habit. Learn what you do not know.

The biggest mistake candidates make in Month 1 is going too fast. They try to solve 5 problems a day, burn out by Week 3, and quit for two weeks. Then they restart, burn out again, and the cycle continues for 11 months.

Do not do this.

Month 1 is about consistency, not volume. Two problems a day. Every day. No exceptions. If you solve them in 20 minutes, great — spend the remaining time understanding the underlying pattern. If one problem takes you 90 minutes, that is also fine — you learned something.

Week 1: Arrays and Hashing

Daily Schedule (2 hours/day on weekdays, 4 hours/day on weekends):

Time Block	Activity
7:00-7:15 PM	Review yesterday's problems (spaced repetition)
7:15-8:15 PM	Solve 2 new problems
8:15-8:30 PM	Read solution editorial for both problems
8:30-9:00 PM	Write pattern notes in your problem journal

Problem Set (14 problems):

• Two Sum, Contains Duplicate, Valid Anagram (hashing)
• Best Time to Buy and Sell Stock, Maximum Subarray (Kadane's)
• Product of Array Except Self, Subarray Sum Equals K (prefix sum)
• Group Anagrams, Top K Frequent Elements (hash + heap)
• Valid Sudoku, Longest Consecutive Sequence
• Encode and Decode Strings, Insert Delete GetRandom O(1)
• 3Sum (your first "hard" pattern problem — two-pointer)

Week 1 Milestone Check:

• You can implement a hash map from scratch in under 5 minutes
• You can explain the time complexity of hash map operations (average vs. worst case)
• You have a physical or digital problem journal with pattern notes for each problem

If You Are Behind: Skip 3Sum and Longest Consecutive Sequence. They will reappear in Month 2. Do not skip the journal — it is more valuable than the problems themselves.

Week 2: Two Pointers, Sliding Window, Stack

Problem Set (14 problems):

• Valid Palindrome, Two Sum II (two-pointer basics)
• Container With Most Water, Trapping Rain Water (two-pointer advanced)
• Best Time to Buy and Sell Stock II, Longest Substring Without Repeating Characters (sliding window)
• Longest Repeating Character Replacement, Minimum Window Substring
• Valid Parentheses, Min Stack (stack basics)
• Evaluate Reverse Polish Notation, Daily Temperatures (monotonic stack)
• Generate Parentheses (backtracking preview)
• Largest Rectangle in Histogram (monotonic stack — hard, attempt it)

Week 2 Milestone Check:

• You can identify a sliding window problem within 30 seconds of reading the description
• You understand when to use a monotonic stack vs. a regular stack
• You have solved at least one "hard" problem without looking at the solution

If You Are Behind: Drop Largest Rectangle in Histogram and Minimum Window Substring. Focus on the core patterns: two-pointer, basic sliding window, basic stack.

Week 3: Linked Lists, Trees (Basics)

Problem Set (14 problems):

• Reverse Linked List (iterative + recursive)
• Merge Two Sorted Lists, Linked List Cycle (Floyd's algorithm)
• Reorder List, Remove Nth Node From End
• Add Two Numbers, Find the Duplicate Number
• Invert Binary Tree, Maximum Depth of Binary Tree
• Same Tree, Subtree of Another Tree
• Lowest Common Ancestor, Binary Tree Level Order Traversal
• Validate Binary Search Tree

Week 3 Milestone Check:

• You can reverse a linked list iteratively and recursively without looking at notes
• You understand the difference between DFS and BFS on trees
• You can explain why Floyd's cycle detection works

If You Are Behind: Skip Subtree of Another Tree and Add Two Numbers. Master the core traversals first.

Week 4: Binary Search, Heaps, and System Design Fundamentals

Problem Set (14 problems):

• Binary Search, Search in Rotated Sorted Array
• Find Minimum in Rotated Sorted Array, Search a 2D Matrix
• Koko Eating Bananas, Median of Two Sorted Arrays
• Kth Largest Element in an Array (heap)
• Find Median from Data Stream (two heaps)
• Merge K Sorted Lists, Task Scheduler
• Top K Frequent Words, Design Twitter

System Design (Weekend — 4 hours): Read Chapters 1-3 of Designing Data-Intensive Applications (DDIA). Watch the "System Design Interview" video by Gaurav Sen on YouTube. Understand: client-server model, latency vs. throughput, SQL vs. NoSQL, caching basics, load balancing basics.

Week 4 Milestone Check:

• You can implement binary search without off-by-one errors
• You understand when to use a min-heap vs. a max-heap
• You can explain the CAP theorem in 2 minutes
• You have completed your first system design sketch (even if it is terrible)

If You Are Behind: Binary search and heaps are non-negotiable. System design reading can spill into Month 2 Week 1.

Month 1 Final Gate: Before moving to Month 2, you must pass this gate:

• Solve "Two Sum" in under 5 minutes (yes, again — it should be automatic)
• Solve "Reverse Linked List" in under 5 minutes
• Explain the difference between a heap and a balanced BST
• Sketch a basic client-server architecture with a load balancer and a database

If you cannot do all four, spend one extra week on Month 1 before proceeding. This is not a race. A weak foundation collapses in Month 4.

---

Month 2: DSA Deepening (Weeks 5-8)

Goal: Move from "I can solve easy/medium problems" to "I can solve hard problems under time pressure." Begin pattern recognition. Start system design case studies.

The volume increases to 3 problems a day. You are now spending 2.5-3 hours on weekdays and 5-6 hours on weekends. This is the hardest month in terms of raw effort. It is also the month where most people quit.

Do not quit.

Week 5: Graphs (BFS, DFS)

Problem Set (21 problems):

• Number of Islands, Max Area of Island (grid DFS/BFS)
• Clone Graph, Course Schedule (topological sort)
• Pacific Atlantic Water Flow, Rotting Oranges (multi-source BFS)
• Word Ladder, Minimum Knight Moves
• Graph Valid Tree, Number of Connected Components
• Alien Dictionary, Reconstruct Itinerary
• Cheapest Flights Within K Stops (Dijkstra preview)
• Walls and Gates, Surrounded Regions
• Redundant Connection (Union-Find preview)
• Word Search, Word Search II (backtracking + Trie)
• The Maze, Shortest Path in Binary Matrix
• Network Delay Time (Dijkstra)

Week 5 Milestone Check:

• You can write BFS and DFS from memory
• You understand when BFS is better than DFS (and vice versa)
• You can explain topological sort to a junior engineer

If You Are Behind: Cut the bottom 5 problems. Graph fundamentals (BFS, DFS, topological sort) are non-negotiable. Dijkstra and Union-Find can wait until Week 6.

Week 6: Dynamic Programming (1D and 2D)

This is the week that separates ₹60L candidates from ₹30L candidates. DP is the most feared topic in DSA interviews — and the most overrepresented at top-tier companies. You will hate this week. That is normal.

Problem Set (21 problems):

• Climbing Stairs, Min Cost Climbing Stairs (DP basics)
• House Robber, House Robber II (state machine DP)
• Coin Change, Coin Change II (unbounded knapsack)
• Longest Increasing Subsequence, Russian Doll Envelopes
• Word Break, Partition Equal Subset Sum (0/1 knapsack)
• Unique Paths, Unique Paths II (grid DP)
• Longest Common Subsequence, Edit Distance
• Longest Palindromic Substring, Palindromic Substrings
• Decode Ways, Maximum Product Subarray
• Burst Balloons, Regular Expression Matching
• Distinct Subsequences, Interleaving String

Week 6 Milestone Check:

• You can identify a DP problem from the problem statement (optimal substructure + overlapping subproblems)
• You can write both top-down (memoization) and bottom-up (tabulation) solutions
• You understand the difference between 0/1 knapsack and unbounded knapsack patterns

If You Are Behind: This is the hardest week in the entire plan. If you are behind, focus on the first 10 problems only. Master the DP pattern recognition framework from Chapter 17. The advanced problems (Burst Balloons, Regular Expression Matching) are nice-to-haves, not must-haves.

Week 7: Advanced Patterns + Pattern Recognition

Problem Set (21 problems):

• Union-Find: Number of Provinces, Accounts Merge, Satisfiability of Equality Equations
• Trie: Implement Trie, Design Add and Search Words Data Structure, Word Search II (review)
• Segment Tree / Fenwick Tree: Range Sum Query (both mutable and immutable)
• Backtracking deep dive: N-Queens, Sudoku Solver, Palindrome Partitioning
• Greedy: Jump Game, Jump Game II, Gas Station, Candy
• Intervals: Merge Intervals, Insert Interval, Non-overlapping Intervals, Meeting Rooms II
• Bit Manipulation: Single Number, Counting Bits, Sum of Two Integers
• Math: Pow(x,n), Multiply Strings, Happy Number

Week 7 Milestone Check:

• You can implement a Trie from scratch in under 10 minutes
• You can implement Union-Find with path compression
• You have a "pattern recognition" cheat sheet (see Chapter 17) that you update daily

If You Are Behind: Prioritize Trie, Union-Find, Intervals, and Backtracking. Segment Tree and Bit Manipulation are lower priority for most interviews.

Week 8: Mock Interviews + System Design Case Studies

DSA (14 problems — mixed review): Pick 2 problems per day from your "struggled with this" list. This is not about learning new patterns. It is about reinforcing what you already know and identifying remaining gaps.

System Design (Weekend — 6 hours): Design a URL shortener (TinyURL). Design a chat system (WhatsApp). Design a news feed (Twitter). For each: draw the architecture on paper, estimate traffic, identify bottlenecks, propose database choices, discuss trade-offs. Use the framework from Chapter 17.

Mock Interview (1 this week): Do your first mock interview. Use Pramp (free) or interviewing.io. It will be terrible. You will freeze. You will forget how to reverse a linked list. This is normal. The point is to experience the feeling of being watched while you code. Record it. Watch it back. Cringe. Learn.

Week 8 Milestone Check:

• You have completed at least one mock interview
• You can whiteboard a URL shortener end-to-end in 45 minutes
• You have identified your top 3 DSA weaknesses and have a plan to address them

Month 2 Final Gate:

• Solve a random LeetCode hard problem in under 45 minutes
• Design a URL shortener on a whiteboard in 45 minutes
• Complete a mock interview without freezing for more than 30 seconds

---

Month 3: System Design + Cloud (Weeks 9-12)

Goal: System design becomes your strength, not your weakness. You can design any system thrown at you. You have hands-on AWS experience, not just theory.

DSA drops to 2 problems/day (maintenance mode). System design becomes the primary focus.

Week 9: System Design Deep Dive — Core Systems

DSA (14 problems): 2 problems/day from your weak areas. Use spaced repetition: every problem you solve, schedule a review 3 days later.

System Design Case Studies (Weekend — 8 hours):

• Design a rate limiter (token bucket, sliding window log, sliding window counter)
• Design a consistent hashing ring
• Design a key-value store (Dynamo-style)
• Design a distributed message queue (Kafka-style)

For each system: write the API, draw the architecture, estimate capacity, discuss consistency vs. availability trade-offs, handle failures.

Week 9 Milestone Check:

• You can explain consistent hashing with virtual nodes
• You can compare at least 3 rate-limiting algorithms with their trade-offs
• You understand the difference between Kafka and RabbitMQ at an architectural level

Week 10: Cloud Hands-On — AWS

DSA (14 problems): Continue maintenance mode. Focus on speed: solve each problem in under 20 minutes.

AWS Hands-On (Weekend — 8 hours): Set up a real project on AWS. Use the free tier. Build:

• An EC2 instance running a Node.js API
• An RDS PostgreSQL database connected to that API
• An S3 bucket for file uploads
• A CloudFront CDN in front of S3
• An Application Load Balancer with auto-scaling group (2 instances minimum)
• A Lambda function triggered by S3 uploads
• An SQS queue between Lambda and a worker

Write all infrastructure as code using Terraform (or Pulumi if you prefer TypeScript). Do not click around in the AWS console. The console is for exploration. IaC is for interviews.

Week 10 Milestone Check:

• You have a working Terraform project that provisions the entire stack
• You can explain the difference between an ALB and an NLB
• You understand S3 consistency model and storage classes

Week 11: System Design — Distributed Systems Patterns

DSA (14 problems): Continue maintenance mode.

System Design (Weekend — 8 hours):

• Design a distributed ID generator (Snowflake, Twitter-style)
• Design a distributed cache (Redis cluster, eviction policies, cache-aside vs. write-through)
• Design a search autocomplete system (Trie + Redis + Kafka)
• Design a video streaming platform (YouTube — chunking, CDN, adaptive bitrate, encoding pipeline)
• Design a payment system (idempotency, reconciliation, double-entry ledger)

Week 11 Milestone Check:

• You can design a payment system with idempotency guarantees
• You understand the difference between cache-aside, read-through, and write-through
• You can explain how YouTube delivers video at scale

Week 12: System Design Mock Interviews + Cloud Review

DSA (14 problems): Speed drills. 15 minutes per problem.

System Design Mocks (2 this week): Do two system design mock interviews. One with a peer. One on interviewing.io. Focus on: structured communication, capacity estimation, trade-off articulation.

Cloud Review: Re-deploy your entire Week 10 project from scratch using only your Terraform code. Time yourself. If it takes more than 30 minutes, your IaC needs work.

Week 12 Milestone Check:

• You have completed at least 2 system design mock interviews
• You can deploy your entire AWS stack from Terraform in under 30 minutes
• You can explain the architecture of any system you use daily (Swiggy, Zerodha, WhatsApp)

Month 3 Final Gate:

• Design a system you have never seen before, in 45 minutes, with a peer evaluating you
• Deploy a full-stack app on AWS using only IaC
• Explain the CAP theorem with real-world examples from systems you have built

---

Month 4: AI/Agents + Mock Interviews (Weeks 13-16)

Goal: Add AI/Agent engineering to your toolkit. This is the differentiator that takes you from ₹60L to ₹1Cr. Start behavioral prep. Ramp up mock interviews.

DSA drops to 1 problem/day (keep the muscle warm). The focus shifts to what makes you stand out.

Week 13: AI Engineering Fundamentals

DSA (7 problems): 1 problem/day. Pick from your "hard" list. Focus on clean code and communication, not speed.

AI Engineering (Weekend — 8 hours):

• Build a RAG (Retrieval-Augmented Generation) system from scratch in Node.js
• Use LangChain.js or build your own orchestration
• Embed documents using OpenAI's text-embedding-3-small
• Store embeddings in Pinecone (or pgvector if you want to stay in PostgreSQL)
• Build a chat endpoint that retrieves relevant documents and generates answers
• Deploy it. Make it work. Show it to a friend.

Code you will write this week:

// A minimal RAG pipeline in Node.js — this is the core pattern
// every AI engineer needs to understand

import { OpenAI } from 'openai';
import { Pinecone } from '@pinecone-database/pinecone';

const openai = new OpenAI();
const pinecone = new Pinecone();
const index = pinecone.index('documents');

async function ingestDocument(text, metadata) {
  // Chunk the document — chunking strategy matters more than you think
  const chunks = chunkText(text, { maxTokens: 512, overlap: 50 });

  for (const chunk of chunks) {
    const embedding = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: chunk,
    });

    await index.upsert([{
      id: `${metadata.docId}-${chunk.index}`,
      values: embedding.data[0].embedding,
      metadata: { ...metadata, text: chunk },
    }]);
  }
}

async function query(question, topK = 5) {
  const questionEmbedding = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: question,
  });

  const results = await index.query({
    vector: questionEmbedding.data[0].embedding,
    topK,
    includeMetadata: true,
  });

  const context = results.matches.map(m => m.metadata.text).join('\n\n');

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'Answer using only the provided context.' },
      { role: 'user', content: `Context:\n${context}\n\nQuestion: ${question}` },
    ],
  });

  return response.choices[0].message.content;
}

This is not production code. It is learning code. But by the end of this week, you will understand the RAG pipeline end-to-end: chunking, embedding, vector search, context injection, generation. When an interviewer asks "Have you worked with LLMs?" you will not say "I've used ChatGPT." You will say "Let me walk you through the RAG system I built."

Week 13 Milestone Check:

• You have a working RAG system deployed and accessible via an API
• You can explain the difference between semantic search and keyword search
• You understand chunking strategies and their trade-offs

Week 14: AI Agents + Behavioral Prep Begins

DSA (7 problems): Continue maintenance.

AI Agents (Weekend — 8 hours): Build an AI agent that can use tools. Give it access to: a calculator function, a weather API, a database query function. The agent should decide which tool to call based on the user's question. Use the ReAct pattern (Reasoning + Acting) or function calling.

Behavioral Prep (2 hours this week): Start your behavioral story bank. Write down 10 stories from your career using the STAR format (Situation, Task, Action, Result). These stories should cover:

• A time you resolved a conflict with a teammate
• A time you made a mistake that affected production
• A time you led a project from idea to delivery
• A time you disagreed with your manager (and were right)
• A time you learned a new technology under pressure
• A time you mentored a junior engineer
• A time you improved a process that saved the team time
• A time you handled a difficult stakeholder
• A time you made a decision with incomplete information
• A time you failed and what you learned

Each story should be 2-3 minutes when spoken. Practice telling them out loud. Record yourself. Delete the recording. Record again.

Week 14 Milestone Check:

• You have a working AI agent that can use at least 3 tools
• You have 10 STAR stories written down
• You have practiced telling 3 stories out loud

Week 15: Mock Interview Gauntlet Begins

DSA (7 problems): Speed + communication. For each problem, practice explaining your thought process out loud while coding. This is harder than it sounds.

Mock Interviews (2 this week): One DSA mock. One system design mock. Both on interviewing.io or with a peer who is also preparing. After each mock, write down exactly what went wrong. Not "I need to study more." Specific things: "I forgot to handle the edge case where the array is empty." "I didn't estimate QPS before diving into the architecture." "I said 'um' 47 times."

Behavioral (2 hours): Refine your STAR stories. Cut the fluff. Every sentence should advance the story. Practice the "2-minute version" of each story — the version you would give if the interviewer looks impatient.

Week 15 Milestone Check:

• You have completed 2 mock interviews and have written feedback for each
• Your STAR stories are tight (under 3 minutes each)
• You can code and talk simultaneously without losing your train of thought

Week 16: AI System Design + Behavioral Mocks

DSA (7 problems): Continue maintenance.

AI System Design (Weekend — 6 hours): Design an AI-powered system end-to-end. For example: "Design a customer support chatbot that can answer questions from a knowledge base, escalate to humans when needed, and learn from every interaction." Cover: embedding pipeline, vector database, LLM selection, prompt engineering, evaluation, monitoring, cost estimation, fallback strategies.

Behavioral Mock (1 this week): Do a full behavioral interview mock. 45 minutes. Have your mock interviewer ask you 5-6 behavioral questions. Treat it like the real thing. Dress like you would for an interview. Sit at a desk. No phone.

Week 16 Milestone Check:

• You can design an AI system end-to-end in 45 minutes
• You have completed a behavioral mock interview
• You can articulate why you want to leave your current company in 30 seconds (this question will come up)

Month 4 Final Gate:

• Build and deploy a RAG system + AI agent in one weekend
• Complete a behavioral mock interview with a stranger and get a "would hire" signal
• Have 10 polished STAR stories ready to deploy in any interview

---

Month 5: Interview Gauntlet (Weeks 17-20)

Goal: Convert preparation into offers. Interview at real companies. Make your mistakes at companies you do not care about.

This is where the plan shifts from preparation to execution. You are not "getting ready" anymore. You are interviewing.

The Tier System

Do not apply to your dream companies first. You will bomb those interviews, and most companies have a 6-12 month cooldown period before you can reapply.

Apply in tiers:

Tier 3 (Weeks 17-18): Companies you do not care about. Startups you have never heard of. Companies with mediocre engineering cultures. The goal is practice. You want to make every possible mistake here so you do not make them at Tier 1.

Tier 2 (Weeks 18-19): Good companies that are not your top choice. Well-known startups. Mid-tier product companies. The goal is to get offers — even if you do not plan to accept them. Offers are leverage.

Tier 1 (Weeks 19-20): Your dream companies. FAANG, top startups, high-paying product companies. By the time you interview here, you have done 8-12 real interviews. You have made your mistakes. You have offers in hand. You are dangerous.

Week 17: Tier 3 Interviews Begin

Schedule 3-4 interviews this week. Use AngelList, LinkedIn, referrals. Target companies with quick interview processes (1-2 rounds). The goal is volume.

Between interviews: Review what went wrong. Fix it immediately. If you bombed a DP problem, spend the evening drilling DP. If your system design was weak on databases, review database internals that night. This is just-in-time learning at its most effective.

Negotiation Prep (1 hour): Read Chapter 17 (The Negotiation Playbook). Understand: never give a number first, always have competing offers, the best time to negotiate is after you have the offer in writing.

Week 17 Milestone Check:

• You have completed at least 3 real interviews
• You have a list of your top 3 recurring mistakes
• You have read the negotiation chapter

Week 18: Tier 2 Interviews Begin

Schedule 3-4 interviews this week. These are companies you would consider joining. The stakes are higher. Your preparation should show.

Between interviews: Same process — review, fix, repeat. But now also track: which companies are moving you forward? Which are rejecting you? Patterns will emerge. If three companies reject you after the system design round, your system design needs work. Fix it before Tier 1.

Week 18 Milestone Check:

• You have completed at least 6 real interviews total
• You have at least one offer or are in final rounds at a Tier 2 company
• You have identified and fixed your top recurring mistake

Week 19: Tier 1 Interviews Begin

This is it. The interviews you have been preparing for.

Schedule 2-3 interviews this week. Fewer interviews, higher stakes. Between each interview, do a light review but do not cram. You are ready. Trust the preparation.

Mindset: You already have offers (or are close). You are not desperate. You are evaluating them as much as they are evaluating you. This confidence shows in your voice, your posture, your answers.

Week 19 Milestone Check:

• You have completed at least one Tier 1 interview
• You have at least one offer in hand (from Tier 2 or Tier 3)
• You are not panicking

Week 20: Tier 1 Continues + Offer Management

Complete remaining Tier 1 interviews. By the end of this week, you should have completed 12-16 real interviews across all tiers.

Offer Management: If you have multiple offers, do not accept any yet. Tell each company: "I am very excited about this opportunity. I am in final stages with a few other companies and expect to have all my options clear by [date 2 weeks from now]. Can we reconnect then?"

This is not rude. This is standard. Every recruiter expects it.

Week 20 Milestone Check:

• You have completed all Tier 1 interviews
• You have at least 2 offers (or are in final rounds)
• You have not accepted anything yet

Month 5 Final Gate:

• 12-16 real interviews completed
• At least 2 offers in hand
• Clear understanding of your market value

---

Month 6: Offer Optimization (Weeks 21-24)

Goal: Convert offers into the best possible compensation package. Make the right decision. Close the loop.

Week 21: Negotiation Execution

This is Chapter 17 in detail, but here is the tactical summary:

1. Never give a number first. When asked about salary expectations: "I am focused on finding the right role and team. I am confident we can find a number that works for both of us if it is the right fit."

2. Use competing offers as leverage. "I have an offer from [Company B] at [X]. I would prefer to join [Your Company] if we can make the numbers work."

3. Negotiate everything, not just base. Base salary, joining bonus, annual bonus, equity (ESOPs/RSUs), sign-on bonus, relocation, learning budget, remote work policy. Everything is negotiable.

4. Get it in writing. Verbal promises are worth zero. Every number, every commitment, every perk — get it in the offer letter.

5. Be willing to walk away. The strongest negotiating position is genuine indifference. If you have two offers and would be happy with either, you cannot lose.

Week 21 Milestone Check:

• You have negotiated at least one offer
• You have all offers in writing
• You have not accepted anything yet

Week 22: Decision Framework

How to choose between offers when the money is similar:

1. Manager quality. You will spend more time with your manager than with your family during work hours. A great manager accelerates your career by 2-3 years. A bad manager sets you back by 2-3 years. Ask to speak with your potential manager for 30 minutes before accepting. Ask: "How do you give feedback?" "How do you decide who gets promoted?" "What is the last piece of critical feedback you gave a team member?" If they cannot answer these questions concretely, that is a red flag.

2. Learning velocity. Will you learn more in 2 years at this company than at the alternative? Consider: tech stack modernity, senior engineers on the team, scale of the problems, autonomy to make architectural decisions.

3. Equity reality check. ESOPs at a Series A startup: assume they are worth zero. RSUs at a public company: discount by 20% for stock price volatility. The only money that is real is the money in your bank account.

4. Growth trajectory. Which role sets you up better for your next jump? A Staff Engineer title at a mid-tier company might be worth more than a Senior Engineer title at FAANG — if you want to be a CTO someday.

Week 22 Milestone Check:

• You have evaluated all offers against the decision framework
• You have spoken with your potential manager at your top choice
• You have made a decision

Week 23: Acceptance and Resignation

Accepting the offer: Send a brief, enthusiastic email. "I am thrilled to accept the offer for [Role] at [Company]. I look forward to joining the team on [Start Date]." That is it. No need to justify your decision or explain your negotiation.

Resigning from your current job:

1. Tell your manager first. In person or on a video call. Not over Slack. Not over email.
2. Keep it simple: "I have decided to move on to a new opportunity. My last day will be [date]. I am grateful for everything I have learned here."
3. Do not explain where you are going. Do not justify your decision. Do not apologize.
4. Your manager may counter-offer. Do not accept it. The reasons you decided to leave have not changed. A counter-offer is a temporary bandage on a permanent wound. Statistics show 80% of people who accept counter-offers leave within 6 months anyway.
5. Send the formal resignation email after the conversation. Keep it professional. CC HR.

Week 23 Milestone Check:

• Offer accepted in writing
• Resignation submitted
• Notice period negotiated (if applicable — in India, 30-90 days is standard; negotiate it down if you can)

Week 24: The Bridge

Before you start:

• Take at least 1 week off between jobs. You have earned it. Do not start a new job burned out.
• Read the new company's engineering blog, internal docs (if you have access), and codebase conventions.
• Set up your home office. Buy the good chair. Your back will thank you.
• Write down 3 things you want to accomplish in your first 90 days. Be specific. "Learn the codebase" is not specific. "Ship one feature to production in my first 30 days" is specific.

Week 24 Milestone Check:

• Notice period served (or in progress)
• Start date confirmed
• First 90-day plan written

---

The Story of Rohan

Rohan was a backend engineer at a Pune-based SaaS company. 5 years of experience. Node.js, PostgreSQL, AWS. Current CTC: ₹22 LPA. He had been "preparing" for 14 months — solving LeetCode problems on weekends, watching system design videos on YouTube, occasionally applying to companies and getting rejected after the second round.

In January 2025, he started this 6-month plan. He followed it exactly. Not perfectly — he fell behind in Month 2, skipped some DP problems, and had to compress Month 3 — but he followed the structure.

By March, he had completed 180 LeetCode problems with pattern notes for each one. By April, he could design a URL shortener, a chat system, and a payment system on a whiteboard without notes. By May, he had built a RAG system and an AI agent that he could demo in interviews. By June, he had completed 14 real interviews across 3 tiers.

In July 2025, Rohan had three offers:

• A Series C startup in Bangalore: ₹65 LPA (₹45L base + ₹20L ESOPs)
• A mid-tier product company in Pune (remote): ₹72 LPA (₹60L base + ₹12L bonus)
• A top-tier product company in Bangalore: ₹95 LPA (₹70L base + ₹15L bonus + ₹10L RSUs)

He took the third offer. Total preparation time: 6 months. Total compensation increase: 4.3x.

Rohan is not a genius. He did not go to IIT. He did not have FAANG on his resume. He had a system, and he followed it.

---

The Daily Template

Every day of this plan follows the same structure. The content changes. The structure does not.

Weekday (2-3 hours):

• 7:00-7:15 PM: Review yesterday's work (spaced repetition)
• 7:15-8:30 PM: Core work (DSA, system design, or AI — depends on the month)
• 8:30-8:45 PM: Pattern notes / journal update
• 8:45-9:00 PM: Plan tomorrow's work

Weekend (5-8 hours):

• 9:00-9:30 AM: Review the week's work
• 9:30 AM-12:30 PM: Deep work block 1 (system design or AI)
• 12:30-1:30 PM: Lunch, walk, no screens
• 1:30-4:30 PM: Deep work block 2 (DSA or cloud hands-on)
• 4:30-5:00 PM: Weekly review — what went well, what did not, adjust next week's plan

Non-Negotiable Rules:

1. No phone during deep work blocks. Put it in another room.
2. No social media before the day's work is done.
3. If you miss a day, do not miss two. One missed day is a rest day. Two missed days is a pattern. Three missed days is a quit.
4. Sleep 7+ hours. Your brain consolidates learning during sleep. Sacrificing sleep for study time is counterproductive.
5. Exercise 3 times a week. A 30-minute walk counts. Your brain works better when your body moves.

---

The Catch-Up Protocol

You will fall behind. Everyone does. Life happens — a production incident at work, a family emergency, a week where you just cannot find the energy. The question is not whether you will fall behind. The question is what you do when it happens.

If you are 1 week behind: Compress the current month. Skip the "nice-to-have" problems (marked in each week's "If You Are Behind" section). Do not skip the milestone checks.

If you are 2 weeks behind: Drop one week from the current month. Which week? The one with the most "nice-to-have" content. For Month 2, drop Week 7 (Advanced Patterns). For Month 3, drop Week 11 (Distributed Systems Patterns — you can review these during Month 4).

If you are 1 month behind: Extend the plan by 1 month. Do not compress 6 months into 5. The plan works because of the progressive overload. Compressing it breaks the progression. Better to take 7 months and succeed than 6 months and fail.

If you are 2+ months behind: Restart from Month 1. Something fundamental is broken — your schedule, your motivation, your study method. Diagnose the root cause before restarting. Are you trying to study after 10 PM when you are exhausted? Switch to mornings. Are you solving problems without understanding the patterns? Go back to the pattern journal. Are you isolated? Find a study partner.

---

The Accountability System

Preparation is lonely. It is easy to lie to yourself about how much you are actually doing. Here is how to stay honest:

1. Track everything. Use a spreadsheet or Notion. Log: date, problems solved, time spent, system design case studies completed, mock interviews done. Review weekly. The data does not lie.

2. Find a study partner. One person. Same level. Same goal. Check in daily: "What did you do today? What are you doing tomorrow? What are you stuck on?" 5 minutes. No more.

3. Public commitment. Tell one person you trust: "I am preparing for interviews. My target is [X] LPA. I am following a 6-month plan. Ask me about my progress in 3 months." The social pressure of not wanting to say "I gave up" is surprisingly powerful.

4. Celebrate milestones. When you pass a month-end gate, do something you enjoy. A nice dinner. A movie. A day off. The brain needs rewards to sustain long-term effort. Do not wait until you have the offer to celebrate.

---

What Success Looks Like

At the end of 6 months, you will not recognize the engineer you have become.

You will have solved 300+ DSA problems — not memorized them, but understood the patterns behind them. You will be able to look at a problem you have never seen and identify the pattern within 30 seconds.

You will have designed 15+ systems end-to-end. You will be able to whiteboard a distributed system in 45 minutes, articulate trade-offs, estimate capacity, and handle failure scenarios.

You will have built real AI systems — a RAG pipeline, an AI agent — that you can demo in interviews. You will not just say "I am interested in AI." You will say "Let me show you what I built."

You will have completed 12-16 real interviews. You will have made your mistakes at companies you did not care about, so that by the time you interviewed at your dream company, you were calm, confident, and prepared.

You will have offers. Multiple offers. And you will have the negotiation skills to turn those offers into a compensation package that changes your life.

The plan works. It has worked for engineers with worse resumes than yours, from worse colleges than yours, with less experience than yours. The only variable is whether you follow it.

The next chapter is about what happens after you get the offers — how to negotiate them into a package that hits the number you have been working toward. Turn the page when you are ready.