"₹12 LPA. No experience. No IIT. No referral. Just the right skills, the right projects, and the right preparation. Here's everything — broken down skill by skill."
I'm going to tell you about someone. 👇
Let's call him Aryan. 🧑💻
Not from IIT. Not from NIT. Tier-3 college. 7.2 CGPA.
Applied to 34 companies. Got 4 interview calls. Cleared 2 final rounds.
Accepted an offer for ₹12 LPA from a product startup. Final year. Before graduation. 🎉
When I asked him what made the difference — he didn't say "I got lucky." He didn't say "I knew someone." He pulled up his laptop and showed me his exact stack. Project by project. Skill by skill.
This post is that conversation. Exactly as he explained it. 👇
No fluff. No inspiration porn. Just the exact skills, the exact projects, and the exact preparation that got a tier-3 college student a ₹12 LPA offer in 2026.
Let's go. 🚀
🧱 Foundation Layer — The Non-Negotiables
Before anything impressive, Aryan had these locked. Completely. 💪
JavaScript — But DEEP, Not Wide 🟨
Not just "I know JavaScript." Not just arrays and functions.
The specific JS concepts he was solid on:
// 1. Closures — asked in almost every interview
function makeCounter() {
let count = 0
return {
increment: () => ++count,
decrement: () => --count,
value: () => count
}
}
// "Explain why count persists" — classic interview Q 🎯
// 2. Promises + async/await — used in every project
const fetchUserData = async (userId) => {
try {
const res = await fetch(`/api/users/${userId}`)
if (!res.ok) throw new Error('User not found')
return await res.json()
} catch (err) {
console.error('Failed:', err.message)
return null
}
}
// 3. Array methods — filter, map, reduce
const topDevs = developers
.filter(dev => dev.yearsExp >= 2)
.map(dev => ({ ...dev, salary: dev.salary * 1.2 }))
.sort((a, b) => b.salary - a.salary)
.slice(0, 5)
// 4. Event loop — interviewers LOVE this
console.log('1')
setTimeout(() => console.log('2'), 0)
Promise.resolve().then(() => console.log('3'))
console.log('4')
// Output: 1, 4, 3, 2 — can you explain why? 🤔
💡 Aryan's tip: "I didn't try to learn every JS concept. I picked the 10 most common interview topics and went DEEP on those. Closures, promises, event loop, prototypes, 'this' keyword — that's 80% of JS interviews right there."
TypeScript — Basic But Consistent 🔷
He wasn't a TypeScript wizard. He just used it in every project consistently.
// The level of TypeScript he had — not crazy, just solid ✅
interface Project {
id: string
name: string
techStack: string[]
isDeployed: boolean
githubUrl: string
liveUrl?: string // optional
}
// Generic types — this impressed interviewers
const getLatest = <T extends { createdAt: Date }>(items: T[]): T => {
return items.sort((a, b) =>
b.createdAt.getTime() - a.createdAt.getTime()
)[0]
}
💡 Aryan's tip: "TypeScript scared me at first. Then I realized — just add types to everything you already write in JavaScript. That's 70% of TypeScript right there. The rest comes naturally."
⚛️ Framework Layer — Where He Stood Out
React — Component Thinking, Not Just Syntax 🔵
Every fresher knows basic React. Aryan knew HOW to think in React. Big difference. 🧠
// Custom hooks — this is what separates beginners from hireable ✨
const useFetch = (url) => {
const [data, setData] = useState(null)
const [loading, setLoading] = useState(true)
const [error, setError] = useState(null)
useEffect(() => {
const controller = new AbortController()
fetch(url, { signal: controller.signal })
.then(r => r.json())
.then(setData)
.catch(err => {
if (err.name !== 'AbortError') setError(err.message)
})
.finally(() => setLoading(false))
return () => controller.abort() // cleanup! 🧹
}, [url])
return { data, loading, error }
}
// Now use it anywhere — clean, reusable, professional 💯
const { data: users, loading, error } = useFetch('/api/users')
💡 Aryan's tip: "I stopped thinking 'what component do I need' and started thinking 'what state do I need and where does it live.' That mindset shift changed everything."
Next.js — Deployed Everything, No Exceptions ⚡
Every single project. Deployed. Live link. No excuses.
// Server components — he understood when to use them 🖥️
// app/dashboard/page.tsx (Server Component — no 'use client')
async function DashboardPage() {
// This runs on the SERVER — no loading state needed!
const data = await fetch('https://api.example.com/stats', {
cache: 'revalidate', // fresh every 60 seconds
next: { revalidate: 60 }
})
const stats = await data.json()
return <Dashboard stats={stats} />
}
// He could explain WHY server components — that's what impressed 🎯
// "It reduces client-side JS, improves initial page load,
// and moves data fetching closer to the data source."
💡 Aryan's tip: "Every interviewer asked me to explain the difference between server and client components. I practiced that answer 20 times. Worth it."
🤖 The Differentiator — AI Integration
This is what made Aryan's profile stand out from every other fresher. 💥
He had ONE project that used AI. That's it. One.
But it was real. It was deployed. And he could talk about it for 10 minutes confidently.
// His AI project — Code Review Assistant 🔍
// The streaming response part impressed interviewers the most
export async function POST(req) {
const { code, language } = await req.json()
const stream = await openai.chat.completions.create({
model: 'gpt-4o',
stream: true, // ← streaming! this is the impressive part
messages: [{
role: 'system',
content: `You are a senior ${language} developer.
Review this code for bugs, performance, and best practices.
Give specific line-by-line feedback.`
}, {
role: 'user',
content: code
}]
})
// Stream the response back to the client in real-time ✨
return new Response(
new ReadableStream({
async start(controller) {
for await (const chunk of stream) {
const text = chunk.choices[0]?.delta?.content || ''
controller.enqueue(new TextEncoder().encode(text))
}
controller.close()
}
})
)
}
In the interview, he said:
"Most AI apps just wait for the full response. I implemented streaming so the review appears word by word — like ChatGPT. It required understanding ReadableStream and Server-Sent Events." 🤯
The interviewer literally said: "Interesting. Tell me more."
That's the moment. That's when you know you're getting the offer. 🎯
💡 Aryan's tip: "Pick ONE AI project. Learn it deeply. Know every line of code. Know why you made every decision. That depth is what impresses — not the number of AI projects."
🔧 The Professional Layer — What Made Him Look Senior
Git Like a Professional 📝
Not just git add . && git commit -m "update". Actual professional Git usage.
# His commit history looked like this 👇
feat: add streaming response for code review API
fix: resolve CORS error on production deployment
refactor: extract AI prompt logic into separate module
perf: implement response caching to reduce API costs
docs: add setup instructions and environment variables
test: add unit tests for code parsing utility
chore: update dependencies to fix security vulnerabilities
💡 Aryan's tip: "I started writing proper commits 3 months before job hunting. By interview time it was habit. Interviewers literally commented on my commit history — twice."
Basic System Design Thinking 🏗️
He wasn't a system design expert. He just thought about scale. 🧠
The question that came up in his final round:
"Your code review tool becomes popular. 10,000 users a day. How do you handle that?"
Aryan's answer (not memorized — just thought out loud) 💭
"Right now every request hits the AI API directly, which is
slow and expensive at scale. I'd add a few things:
1. 🗄️ Cache common code patterns — same React hook reviewed
100 times doesn't need 100 API calls
2. 📋 Request queue — instead of failing under load, queue
requests and show a 'position in queue' to the user
3. 💰 Rate limiting per user — free tier gets 5 reviews/day,
premium gets unlimited — also a monetization opportunity
4. 📊 Analytics — track which languages get reviewed most,
which errors are most common — product insights
I haven't built all of this yet, but that's the direction
I'd take it."
The interviewer's response: "That's exactly the kind of thinking we're looking for." 🎯
💡 Aryan's tip: "I didn't study system design from a book. I just asked 'what if this gets 100x bigger?' for every project I built. That habit gave me real answers in interviews — not memorized ones."
Environment Variables and Security 🔐
Small thing. Huge signal.
# .env.local — he knew this cold
OPENAI_API_KEY=sk-...
NEXT_PUBLIC_APP_URL=http://localhost:3000
DATABASE_URL=postgresql://...
# .gitignore — never committed secrets 🔒
.env.local
.env.production
node_modules/
.next/
Most freshers push their API keys to GitHub by accident. Aryan never did. Interviewers actually asked about this — and he had a clear answer. 💪
📊 Aryan's Exact Portfolio (What Was Actually Deployed)
🌐 Portfolio: aryan-dev.vercel.app
└── Clean, fast, mobile responsive
🤖 Code Review Assistant: codereview-ai.vercel.app
└── React + Next.js + OpenAI streaming
└── 150+ reviews done by real users
└── ⭐ The project that won him the offer
📊 Dev Expense Tracker: devexpenses.vercel.app
└── Next.js + Supabase + Recharts
└── Used personally every month
└── Shows fullstack + data viz skills
🔍 OSS Issue Finder: oss-finder.vercel.app
└── React + GitHub API
└── Helps devs find beginner-friendly issues
└── 80+ developers used it
3 real projects. All deployed. All with real users.
Not 12 projects. 3. But SOLID 3. 🎯
📚 How He Prepared for Interviews (The Actual Schedule)
6 weeks out from placement season:
📅 Week 1-2: JavaScript Deep Dive
├── Closures, prototypes, 'this' keyword
├── Event loop + microtask queue
├── Promises, async/await, error handling
└── 2 LeetCode problems per day (easy/medium only)
📅 Week 3-4: React + Next.js Revision
├── Re-read every project, understand every line
├── Custom hooks — built 5 from scratch
├── Server vs client components — explained out loud daily
└── Practiced explaining projects using STAR format
📅 Week 5: System Design Basics
├── Client-server model
├── REST APIs, caching, rate limiting
├── Applied "what if 100x bigger" to each project
└── Watched 10 junior-level system design videos
📅 Week 6: Interview Simulation
├── Mock interviews with friends (recorded them 🎤)
├── Prepared 5 questions for every company
├── Researched each company's stack before interview
└── Practiced behavioral questions with real stories
💡 Aryan's tip: "Week 6 was the most important. I did 8 mock interviews. I was brutal about reviewing recordings. The first 3 were painful to watch. By mock interview 7, I felt ready. And I was."
🎯 The Honest Summary
Here's what Aryan had that most freshers don't: 👇
✅ Deep JS fundamentals (not surface level)
✅ TypeScript in every project (consistently, not perfectly)
✅ React component thinking (not just syntax)
✅ Next.js with deployed projects (always live links)
✅ ONE impressive AI project (deep, not broad)
✅ Professional Git habits (conventional commits)
✅ Basic system design thinking (habit, not memorized)
✅ 3 real deployed projects with real users
✅ 6 weeks of focused interview preparation
✅ Mock interviews until it felt natural
What he did NOT have:
❌ IIT/NIT degree
❌ 9+ CGPA
❌ Referral or connection at the company
❌ 2 years of experience
❌ 50 LeetCode hard problems solved
❌ A perfect portfolio with 10 projects
The gap between ₹4 LPA and ₹12 LPA for a fresher in 2026 is not talent. It's not luck. It's not connections.
It's preparation depth. It's project quality. It's interview mindset. 💯
All three are learnable. Starting today. 🚀
💬 Your Turn!
Where are YOU in this journey right now? 👇
Drop in the comments:
- 🧱 Building foundations?
- ⚛️ Learning React/Next.js?
- 🤖 Working on your AI project?
- 🎯 In interview prep mode?
Let's track progress together! And if Aryan's story gave you a push — drop a ❤️ and share this with someone who needs to see it. 🙏
You don't need the perfect background. You need the right skills and the right preparation. Go get both. 🔥
🔖 P.S. — Save the 6-week preparation schedule. Whenever your placement season starts, pull this out and follow it week by week. It works.
Top comments (0)