Back to Blogs
How to Prepare for Placements in Third Year: Complete Roadmap to a Good Package.

How to Prepare for Placements in Third Year: Complete Roadmap to a Good Package.

Lets Code•June 26, 2026

If you are in third year and you keep hearing words like DSA, system design, referrals, NQT, LeetCode, and you have no idea where to actually start, this is for you. You are not behind. Most people in your batch are exactly where you are, they are just quieter about it.

Third year is the single most important year for your placement. Final year is mostly execution and giving interviews. Third year is where you build the thing that gets you those interviews. Get this year right and placement season feels calm. Waste it and you spend final year panicking.

So let me lay it out plainly. No fluff, no motivation speech. Just what works, in what order, and where to learn each piece for free.

First, what does a “good package” even mean

Before chasing a number, understand the landscape so you target the right thing.

Companies that come to campus roughly fall into four buckets:

Mass recruiters like TCS, Infosys, Wipro, Cognizant, Accenture, Capgemini, HCL. They hire in huge numbers. Packages are usually in the 3.5 to 7 LPA range depending on the role and test score. Aptitude is the main filter here. If you clear the test and speak decently, you are mostly through.

Mid tier product and service-product companies like Deloitte, ZS, Publicis Sapient, Persistent, and many funded startups. Packages here often sit in the 7 to 15 LPA range. They want decent DSA, real projects, and clear fundamentals.

Product companies and good startups like Amazon, Microsoft, Flipkart, Atlassian, Walmart, and well-funded startups. This is where 15 to 40 LPA lives. Heavy DSA, strong projects, sometimes basic system design, and almost always good problem solving under pressure.

Dream tier like Google, top trading firms, and a few elite startups. Very hard DSA, deep CS, and usually a referral or a strong online presence to even get shortlisted.

A “good package” for most third years realistically means breaking out of the mass recruiter bucket and landing somewhere in the 8 LPA and above range. That is fully achievable in 12 to 15 months if you start now. The way you get there is not luck. It is DSA plus projects plus fundamentals plus a clean resume plus showing up to enough interviews.

If you want the full picture of how each company type hires and what their rounds look like, read the complete placement roadmap on Let’s Code: https://www.lets-code.co.in/articles/placement

The honest truth about where you stand in third year

You have roughly 10 to 15 months before your placement season starts, depending on your college and batch. That is enough time to go from confused to genuinely strong, but only if you treat it like a slow build instead of a last minute cram.

Here is the mindset shift that matters. You do not need to be a genius. You need to be consistent. A student who solves three problems a day for a year beats a student who solves thirty in one weekend and then disappears for a month. Placement is a compounding game. Small daily reps stack up into something that looks like talent by the time interviews start.

The second truth. Collecting resources is not preparation. You will be tempted to download fifty PDFs and bookmark twenty playlists and feel productive. That feeling is fake. Pick one resource per topic and actually finish it. The plan below tells you exactly which ones.

Your year at a glance

Here is the shape of the whole plan before we go deep. Treat this as the skeleton.

  1. Pick one programming language and get genuinely comfortable with it. About 3 to 4 weeks.
  2. Learn DSA properly, topic by topic, while solving daily. This runs across most of the year.
  3. Cover CS fundamentals, which are OS, DBMS, CN, and OOPs. Roughly 6 to 8 weeks running in parallel.
  4. Build two to three real projects you can talk about for ten minutes each.
  5. Prepare aptitude if you are targeting mass recruiters or have a campus aptitude test.
  6. Aim for a summer internship after third year. This single thing can change your final package.
  7. Fix your resume, LinkedIn, and GitHub before season starts.
  8. Solve company previous year questions and do company-specific prep.
  9. Do mock tests and mock interviews until interviews stop scaring you.
  10. Build a referral and off-campus pipeline so you are not depending only on campus.

Now the detail.

Phase 1. Pick one language and stop switching

Choose one language and commit to it for the whole journey. Switching languages mid preparation is the most common way students waste two months.

For most people targeting product companies, C++ or Java is the safe choice. C++ has a clean and fast standard library which is great for DSA. Java is very interview friendly and widely accepted. Pick Python only if you are leaning toward data, ML, or backend scripting and you are already comfortable with it.

What you actually need to be solid on:

  • Variables, loops, conditions, functions
  • Arrays and strings, and how to manipulate them
  • Object oriented basics, which are classes, objects, inheritance, polymorphism, abstraction, encapsulation
  • The built in data structures of your language, like vectors, maps, sets in C++ or the Collections framework in Java
  • Basic exception handling and input output

Free starting points are linked inside the placement roadmap, including W3Schools tutorials for Java and learn-cpp for C++. Give this phase three to four weeks and then move on. Do not aim for perfection here. You will get better at the language automatically while doing DSA.

Phase 2. DSA is the core. Treat it like a daily habit

This is the spine of everything. Almost every coding round and technical interview tests DSA. The good news is that there is a fixed order to learn it, and once you know the patterns, most problems start to feel familiar.

Follow this order. Do not jump ahead.

Foundations. Arrays, two pointers, sliding window, basic searching and sorting, then strings, then basic math like prime numbers, GCD, LCM.

Core structures. Linked lists, stacks, queues, hashing. These show up constantly.

Non linear structures. Binary trees and traversals, binary search trees, heaps and top K problems, tries.

Advanced. Graphs with BFS, DFS, topological sort, shortest paths. Then dynamic programming, which scares everyone but is just pattern recognition once you do enough of it. Then backtracking, binary search on the answer, and greedy.

For the full topic-by-topic breakdown and the order to follow, use the Let’s Code DSA roadmap: https://www.lets-code.co.in/articles/dsa

For the exact problems to grind, the LeetCode Top 150 list is the highest return set you can solve: https://www.lets-code.co.in/articles/leetcodetop150questions

How to actually practice so it sticks:

  • Solve daily. Even 45 focused minutes beats a weekend binge.
  • Do not just get the answer. Understand why the pattern works so you can reuse it.
  • After solving, read the editorial even when you were right. There is often a cleaner approach.
  • If you are stuck for more than 30 minutes, take a hint, not the full solution.
  • After the first two weeks, time yourself. Aim for 30 minutes on a medium.

If you want a structured push, the Let’s Code 100 Days DSA Challenge gives you a daily target so you do not have to decide what to solve each day: https://www.lets-code.co.in/100-days-dsa-challenge/

A realistic pace for a third year is two to four problems a day. Over a year that is well past a thousand problems, which is more than enough for most companies below the dream tier.

Phase 3. CS fundamentals. The round that quietly eliminates people

Operating systems, DBMS, computer networks, and OOPs are tested heavily by service companies and asked even at product companies. A lot of strong coders get rejected here because they ignored theory.

Cover these alongside your DSA, not after. One topic every couple of days works well.

Operating systems. Processes and threads, CPU scheduling, deadlocks, memory management and paging, synchronisation with mutex and semaphores.

DBMS. ER model, keys, SQL queries and joins, normalisation up to BCNF, ACID properties, indexing. Practice SQL queries by hand, do not just read them.

Computer networks. OSI and TCP/IP models, IP addressing and subnetting, TCP versus UDP, the 3 way handshake, how DNS and HTTPS work end to end.

OOPs. The four pillars with real examples, compile time versus runtime polymorphism, and the basics of SOLID principles.

The placement roadmap links the exact free playlists for each of these, mostly Gate Smashers and Neso Academy, which are the standard picks. You do not need anything fancier than those.

Phase 4. Build projects you can actually defend

Projects are your biggest differentiator, especially if your DSA is only average. In interviews, a project you built and understand deeply gives you fifteen minutes of confident talking, while a tutorial clone you copied falls apart in two questions.

What a strong project looks like:

  • It solves a real problem instead of being a tutorial copy
  • It has a working demo or a live deployment
  • The code is clean and pushed to GitHub
  • You can explain every decision, why you chose each technology, what was hard, and how you would scale it

Aim for two to three projects across third year. One can be substantial. Pick a domain that matches the roles you want, whether that is full stack web, backend APIs, or ML.

For idea lists with source code to learn from, use the Let’s Code final year projects page, and then build your own version rather than copying: https://www.lets-code.co.in/articles/finalyearprojects

One more thing. Build in public. Push everything to GitHub and post short updates on LinkedIn about what you built. This quietly builds a profile that recruiters and referrers notice later.

Phase 5. Aptitude. Boring but it gates the mass recruiters

If TCS, Infosys, Wipro, and similar companies come to your campus, their first filter is an aptitude and reasoning test. Plenty of good coders get knocked out here before they ever show their coding. Do not let that be you.

You need quantitative aptitude, logical reasoning, and verbal ability. The trick is volume and speed. Learn the shortcut methods early because they save you 30 to 40 seconds per question, and in these tests time is the real enemy.

Use the Let’s Code aptitude roadmap for the full topic list and a study plan: https://www.lets-code.co.in/articles/aptituderoadmap

Practice on IndiaBix and solve previous year aptitude sets. The TCS NQT aptitude PYQs on Let’s Code are a great place to see the actual style of questions: https://www.lets-code.co.in/previousyearcodingquestion/tcsnqtaptitude

You do not need to start aptitude in month one. Begin serious aptitude practice about four to five months before your season and keep it steady. Solving close to a thousand questions before season puts you ahead of most of the room.

Phase 6. Get a summer internship after third year

This is the lever most students underuse. A summer internship between third and final year does three things. It puts real industry experience on your resume, it sometimes converts into a full time offer with a strong package, and it makes your final year interviews much easier because you can talk about real work.

Start applying for internships in the second half of third year. Look at company career pages, AngelList style startup boards, and off-campus drives. The Let’s Code jobs page and startup directory list openings and hiring startups across India:

Even an unpaid or small startup internship where you ship real features is worth more on your resume than another certificate.

Phase 7. Fix your resume, LinkedIn, and GitHub before season

Your resume is read by software before any human sees it. An applicant tracking system scans it first, and a messy format gets you filtered out silently. So the format matters as much as the content.

Resume basics that actually matter:

  • One page, single column, no tables or graphics or fancy columns
  • Lead with skills, then projects, then education
  • Use action words and numbers. “Reduced API response time by 40 percent” beats “worked on backend”
  • Add GitHub links to every project
  • Zero spelling mistakes, save it as a PDF with your name in the filename

Use the Let’s Code ATS friendly resume templates to start from a clean base: https://www.lets-code.co.in/articles/resume

Then run it through the free AI tools so you are not guessing:

For LinkedIn, drop the generic “Student at XYZ College” headline. Write something like “Full Stack Developer, DSA, React, Node.js, looking for SDE roles 2026”. Fill the about section, add your projects, and start connecting with seniors at the companies you want.

Phase 8. Solve previous year questions and do company-specific prep

Once you know which companies are coming, stop preparing generically and start preparing for them specifically. Companies repeat patterns, and previous year questions are the closest thing to seeing the paper before the exam.

Let’s Code has company-wise PYQs for most major recruiters:

Also read real interview experiences before you sit for a company. Knowing how a round actually went for someone last year is worth a lot: https://www.lets-code.co.in/interview-experience/

And for the topic-wise theory questions interviewers love to ask, keep this handy: https://www.lets-code.co.in/interview/interviewquestions

Phase 9. Mock tests and mock interviews

Solving problems alone is not the same as performing under pressure. The gap between the two is closed by mocks, and students who do them consistently outperform students who only grind in private.

Take full length mock tests under real conditions, no phone, strict timing. The free Let’s Code mock MCQ test is a good place to practice the test format: https://www.lets-code.co.in/dashboard/mocktest/

For mock interviews, use the AI Mock Interview tool to practice speaking your solutions out loud, then also do peer mocks where you and a friend take turns interviewing each other. Record yourself once and watch it back. You will instantly see your filler words, your pauses, and the moments you freeze. The single most valuable interview skill is thinking out loud calmly, and that only comes from reps.

AI Mock Interview: https://www.lets-code.co.in/dashboard/mocktest/

Phase 10. Build a referral and off-campus pipeline

Do not bet everything on campus placements. Many of the best offers come from off-campus applications and referrals. A referral often gets your resume past the first filter that auto rejects most online applications.

How to do this without being awkward:

  • Find people working at your target companies, ideally seniors from your college
  • Send a short, specific, polite message, not a copy paste plea
  • Have your resume ready and a one line on why you fit the role

Let’s Code has ready cold email and referral templates so you are not staring at a blank message: https://www.lets-code.co.in/articles/coldemailtemplates

Use the AI Job Finder to surface live openings that match your resume so you spend time applying instead of searching: https://www.lets-code.co.in/dashboard/job-finder/

And join the community channels for daily job and internship alerts so opportunities come to you:

A simple month by month plan for third year

Adjust the start point to where you are, but the sequence holds.

Months 1 to 2. Lock in one language and get comfortable. Start DSA foundations, which are arrays, strings, two pointers, hashing. Begin one CS fundamental topic on the side.

Months 3 to 4. Move into core DSA, which are linked lists, stacks, queues, trees. Keep one CS subject running. Start your first real project.

Months 5 to 6. Advanced DSA, which are graphs and dynamic programming. Finish your first project and deploy it. Begin aptitude practice. Start applying for summer internships.

Months 7 to 8. Do a summer internship if you got one, or build a strong second project. Keep DSA revision going so you do not lose momentum.

Months 9 to 10. Finalise resume, LinkedIn, and GitHub. Run them through Job Ready Score and the Resume Optimizer. Ramp up aptitude. Start company PYQs for the firms hiring at your campus.

Months 11 to 12. Heavy mock tests and mock interviews. Company-specific PYQs and interview experiences. Polish your “tell me about yourself” and your project explanations. Build your referral pipeline.

By the time season starts, you walk in with a year of reps behind you instead of a week of cramming.

Common mistakes third years make

  • Switching languages or roadmaps every few weeks and never finishing one
  • Hoarding resources and confusing that with studying
  • Ignoring CS fundamentals because DSA feels more exciting
  • Building tutorial clones they cannot explain in an interview
  • Treating aptitude as beneath them and then failing the first round
  • Waiting for final year to start, then trying to do a year of work in two months
  • Preparing only for campus and ignoring off-campus and referrals entirely

You do not have to avoid all of these perfectly. Just do not do all of them.

A weekly routine that actually works

You do not need ten hours a day. You need steady hours that you actually keep. A realistic third year week looks like this:

  • Two to four DSA problems daily, with one editorial read each time
  • One CS fundamentals sub topic every two days
  • A few hours on the weekend for project work
  • Aptitude practice on alternate days once you are four months out
  • One mock test or mock interview every week or two as season approaches

Consistency at this level for a year is genuinely enough to land a good package. The students who get the offers are rarely the smartest in the room. They are the ones who kept showing up.

Where to start today

If this feels like a lot, do not try to do everything at once. Just start here, today:

  1. Pick your language and decide it is final.
  2. Open the Let’s Code DSA roadmap and solve the first two problems: https://www.lets-code.co.in/articles/dsa
  3. Read the full placement roadmap once, slowly, so the whole year makes sense: https://www.lets-code.co.in/articles/placement
  4. Run your current resume through the Job Ready Score to see where you stand: https://www.lets-code.co.in/dashboard/job-ready-score/
  5. Join the WhatsApp or Telegram channel so job alerts reach you without effort.

Everything on Let’s Code is free, no paywalls. The full AI toolkit, with the mock interview, resume scan, job finder, cover letter writer, and more, lives here: https://www.lets-code.co.in/dashboard/

Third year is not the year to panic. It is the year to build quietly while everyone else waits. Start today, keep it boringly consistent, and final year you becomes the person giving advice instead of asking for it.

L

Lets Code

Contributing Writer

Share this article