Do Priority A perfectly. Build 2 flagship projects (front + back + deployed). Solve DSA daily (timed mocks weekly). Apply for internships / job openings aggressively once you have one deployed full-stack project + 150–200 DSA problems. Do Priority B after Priority A is stable.
Goal: 12–18 months → be comfortable with medium → hard LeetCode + 500 quality problems over time.
Daily
- 60–120 min: focused practice (one topic per day). Start with arrays/strings → two-pointers → hashmaps → sliding window → stacks/queues → trees → graphs → dp → greedy/heaps → sorting/searching.
- 1 timed LeetCode problem (45–60 min) 3×/week (simulate interview pressure).
Weekly
- 1 mock session (90–120 min): 2 problems (one medium, one hard) + code review.
- 1 contest (Codeforces/CodeChef) every 1–2 weeks (optional, huge long-term benefit).
Monthly targets
- Month 1–3: Master arrays/strings/hashmaps + 150 easy→medium problems.
- Month 4–9: Trees/graphs + medium problems (200 more).
- Month 10–15: Dynamic programming, advanced graphs, tough mediums/hards (150-200).
- Ongoing: Review patterns, redo mistakes, do timed mocks.
Resources
- GeeksforGeeks (concepts & your course).
- LeetCode (practice + premium patterns if you can).
- NeetCode / Blind 75 (pattern lists).
- System design (see below) — starts after you have backend basics.
Deliverables (DSA)
- Completed folders on GitHub with solved problems (well-commented).
- 3 timed mock recordings / transcripts showing improvement.
I number them 1 → 12: finish #1 before moving to #2 etc. You may overlap DSA with everything below (DSA is daily, not sequential).
- What / Why: Basic building blocks of every web UI. Recruiters notice polish. You must make a pixel-correct portfolio and components.
- Deliverable: Live portfolio + 2 small UI pages (one responsive blog/project page, one contact form).
- Resources: MDN HTML & CSS docs; freeCodeCamp "Responsive Web Design".
- What / Why: Language used everywhere (frontend + Node). Must understand closures, async/await, event loop, modules.
- Deliverable: 5 micro-tasks: debounce, promise→async refactor, DOM widget, fetch + caching demo, module bundling demo.
- Resources: MDN JS, YouTube JS deep-dive playlists, complete JS sections of your Udemy JS courses.
- What / Why: Collaboration, version history, PRs are interview basics.
- Deliverable: Repo with branch→PR→merge + GitHub Actions: run tests on push.
- Resources: GitHub Learning Lab; Git documentation.
- What / Why: Backend for your full-stack projects. Learn request lifecycle, middleware, async handling, REST.
- Deliverable: Production-like REST API (auth, users, products) with validation and tests.
- Resources: ZTM Node course, Jonas Schmedtmann Node course.
- What / Why: ACID transactions, joins, analytics — needed for serious backend roles.
- Deliverable: Order/payments microservice (migrations + sample transactions).
- Resources: Postgres docs; Prisma docs.
- What / Why: Fast prototyping, common with Node. You must know both SQL and NoSQL use-cases.
- Deliverable: Product catalog API using Mongo + aggregation queries.
- Resources: MongoDB docs; Maximilian MongoDB course.
- What: Type-safe DB client (Prisma) and Mongo ODM (Mongoose).
- Why: Faster dev & fewer SQL mistakes; Prisma integrates well with TypeScript.
- Deliverable: Prisma schema + migrations + queries.
- What / Why: Industry-standard for frontend roles. Most product roles expect React.
- Deliverable: React SPA (project #1 front-end) that consumes your API.
- Resources: React docs + your Udemy React courses (Maximilian / ZTM).
- What / Why: Server side rendering, routing, production features. Strong preference for Next in product companies.
- Deliverable: Portfolio or project deployed on Vercel with at least one SSR/SSG page.
- Resources: Next.js docs + course you own.
- What / Why: Many hires require TS. Convert an existing project to strict TS — THIS proves scale readiness.
- Deliverable: Convert the backend API to strict TypeScript (no
any), type-safe controllers/services. - Resources: TypeScript handbook; hands-on TS projects.
- What / Why: Tests = production-ready mindset; interviews ask about testability.
- Deliverable: Jest unit tests, Supertest integration tests for APIs, CI runs tests and fails on <80% coverage.
- Resources: Jest docs; Supertest docs; Playwright/Cypress for e2e (optional minimal).
- What / Why: Containerize and deploy. You must be able to deploy a real app on AWS or Vercel. Interviewers ask deployment questions.
- Deliverable: Multi-stage Dockerfile + docker-compose for local dev + one app deployed (API on EC2 or container registry → ECS/ECR OR simple EC2 + Nginx).
- Resources: Docker docs; AWS Free Tier tutorials.
- What / Why: Gives you flexibility (many companies use GraphQL), more efficient client-server interactions, and subscription setups.
- Deliverable: when doing your flagship backend project, you can add a GraphQL endpoint to your REST API. That single move will make your resume stand out in backend-heavy roles.
- Resources: GraphQL with Node.js by Academind (Maximilian Schwarzmüller)
- What / Why: Many apps need live updates / chat / notifications — knowing sockets is a strong differentiator.
- Deliverable: Design docs for URL shortener, chat, and e-commerce (HLD + LLD). Hardened API: rate-limits, helmet, input validation.
- Resources: Traversy Media Socket.io Crash Course (1 hr) + Node.js + Socket.io + React Chat App by freeCodeCamp (3 hrs)
- What / Why: For 20+ LPA, system design questions and security hygiene are mandatory. Also learn caching, indexing, read/write patterns.
- Deliverable: Design docs for URL shortener, chat, and e-commerce (HLD + LLD). Hardened API: rate-limits, helmet, input validation.
- Resources: Gaurav Sen videos; Designing Data-Intensive Applications; OWASP Top 10.
Goal: 12–15 months to comfortably solve medium→hard interview problems. Aim for 300–400 quality problems as baseline for 20+ LPA; 500+ is elite.
-
Daily (minimum): 90–120 minutes focused practice.
- Weekdays: 1 topic + 1 easy/medium problem (45–60 min).
- Weekends: 2–3 hours — 1 timed medium and revisit mistakes.
-
Timed practice: 3×/week do 45–60min timed LeetCode problems (simulate interview).
-
Mock interview: 1×/week (90–120 min) — pair or record yourself solving 2 problems (one medium + one medium-hard). Do code review.
-
Monthly targets:
- Months 1–3: arrays/strings/hashmaps/two pointers + 150 easy→medium.
- Months 4–9: trees, graphs, BFS/DFS, heaps — 150–200 medium.
- Months 10–15: DP, advanced graphs, hard problems — 150+.
-
Contest schedule: Start CodeChef/Codeforces monthly after month 2. Do one contest bi-weekly if possible; treat contests as training, not score-chasing.
-
Language: Stick to Java (you already know it) or JS/TS for backend. For competitive programming you can use C++ if you want micro-win speed; not required for interviews. My blunt pick: use Java for DSA (interview acceptable) unless you're already fluent in C++.
Numbered sequence after Priority A:
-
Redis + Background Jobs (BullMQ) — caching & async processing.
- Why: Improves latency, scalable emails/jobs.
- Deliverable: Cache product list; background job to send emails.
-
CI/CD (GitHub Actions) — full pipeline tests→build→deploy.
- Why: Real engineering expects automated pipelines.
- Deliverable: Pipeline to deploy to staging on PR merge.
-
Advanced TypeScript patterns — generics, utility types.
- Why: Many product codebases require strong TS skill.
-
Cloud deeper (S3, RDS, Lambda, API Gateway) — serverless basics.
- Why: Helps design cost-effective systems and interviews.
-
Observability (Sentry/Prometheus/Grafana) — monitoring and tracing.
- Why: Production debugging, p95 latency analysis.
-
Event streaming (Kafka) — for big distributed systems.
- Why: Required for infra-heavy roles.
-
Kubernetes + Terraform — infra-as-code + orchestration (only if you want infra roles).
- Why: Necessary for infra-specialist jobs; great differentiator.
-
RAG / Vector DB / LangChain — AI product skill (edge for AI product roles).
- Why: Rapidly demanded for AI features, but optional for standard product roles.
- HTML → CSS → JS (ES6) → Git → React → Node (JS) → Postgres/Mongo → TypeScript → Docker → Tests → Deploy to AWS. (All Core.)
- After core: Kubernetes, Terraform, Redis, Kafka, Observability. (Add High-value afterward.)
- AI features (LangChain, vector DBs) — start after you can deploy and run infra reliably (useful as differentiator for 20+ LPA).
You must have 2 flagship projects (one simple, one complex). Each must be deployed, typed (TS where possible), have tests, CI, and a clear README + architecture doc.
- Type: Full-stack CRUD app (React + Next.js front, Node/Express + Postgres/Mongo backend).
- Examples: Job portal / Notes app with auth & roles.
- Deliverable: Live link, GitHub repo, README + deployment guide.
- Deadline: By end of Phase 1 (Nov15 → Feb28).
- Type: Production-like microservice app. E-commerce microservices or a social app (users, products/posts, payments, search).
- Must include: Auth, payments stub, Redis cache, background jobs, Prisma/Postgres, Dockerized, CI, deployed staging.
- Deliverable: Live staging, architecture doc (HLD + LLD), performance numbers (p50/p95).
- Deadline: By end of Phase 3 (Jul–Dec 2026).
- Type: RAG chatbot or search + LLM integration (LangChain + vector DB).
- Why: Differentiator for AI product roles.
- Deadline: After Projects A & B, Q3–Q4 2027.
-
Start contests: Month 2 (Dec 2025) — CodeChef/Codeforces monthly participation. Aim 1 contest/2 weeks if possible.
-
Competitive programming: Optional but beneficial. Do CP for 3–6 months if you want to sharpen speed. Don’t let CF consume your project time.
-
Hackathons: Start after Project A is deployed (March 2026). Join 2–3 hackathons in next 6 months (Apr–Sep 2026). Use hackathons to:
- Build quick features for your portfolio.
- Network & win recognitions → good resume bullets.
-
How to succeed in hackathons: Keep scope tiny, reuse existing codebase, build one real feature, focus on deployment, prepare a 3-minute demo.
When to apply: Rolling from Feb–Mar 2026 (start applying as soon as you have Project A + ~150 DSA problems). Apply continuously.
Roles to target:
- SDE / Backend Intern (Node/TS/Java) — prefer Node + Postgres/Mongo.
- Full-stack Intern — React + Node.
- Platform / Tools Intern — if you have infra skills (later).
Application process (typical):
- Online test / coding challenge (HackerEarth/CodeSignal/Company portal).
- Technical phone screen - 1 medium DSA problem + behavioral.
- Onsite / Virtual interview - 2–3 rounds: DSA, system design (small), backend design + behavioral.
How to apply effectively:
- Start with targeted companies (startups + product companies) with 2–3 tailored applications/day.
- Use alumni & LinkedIn referrals heavily.
- Keep one “interview-ready” resume version and a short pitch.
Resume
- One page only. Top 3 bullets first: (1) flagship project + live URL, (2) internships/OSS (if any), (3) DSA achievement / contest rank (if good).
- For each project: one line summary (what it does), tech stack, 2 measurable bullets (what you built + results e.g., 99% test coverage, 1000 monthly users simulated, 200ms p95).
- Skills section: list languages, frameworks, infra. Prioritize those you know well.
- Add links: GitHub, live project URL, LinkedIn.
- Professional headline: “Aspiring SDE | React • Node • Postgres • TypeScript | Looking for internships (Summer 2026)”.
- Summary: 3–4 lines: what you build, what you’re learning, what you want.
- Projects: add repos and short descriptions.
- Post 1 technical writeup every 6–8 weeks.
Portfolio
- Home, projects, contact + downloadable resume.
Phase 0 — Prep (Now → Nov 14, 2025)
- Read MDN basics, set up GitHub, pick start date, prepare daily schedule.
Phase 1 — Foundations (Nov 15, 2025 → Feb 28, 2026) — 3.5 months
- HTML/CSS (2 weeks), JS (6 weeks), React (6 weeks overlapping), Project A deployed, Git, DSA daily.
- Milestone: Live portfolio + Project A + 150 DSA problems.
Phase 2 — Backend Core (Mar 1 → Jun 30, 2026) — 4 months
- Node + Express, Postgres + Prisma, Mongo basics, Docker, basic tests. Start applying internships (Feb–Mar window) with Project A. Start OSS small PRs. Continue DSA.
- Milestone: REST API deployed + internship interviews ongoing.
Phase 3 — Productionize (Jul 1 → Dec 31, 2026) — 6 months
- TypeScript conversion, testing, Dockerized multi-service, Redis + job queue, CI, initial monitoring. Hackathons + OSS contributions. Project B development and deployment begins.
- Milestone: Project B deployed (flagship), CI + Docker + tests.
Phase 4 — System Design & Infra (Jan 1 → Jun 30, 2027) — 6 months
- System design deep-dive, Kubernetes basics (optional), Terraform basics (optional), advanced cloud features (Lambda/S3). Continue DSA (hard problems).
- Milestone: 3 design docs + k8s demo (optional).
Phase 5 — Flagship & Interview Push (Jul 1, 2027 → Jun 30, 2028) — 12 months
- Build RAG/demo if desired; heavy mock interviews; targeted applications to product companies; placement/hiring push.
- Milestone: 2 flagship projects + 3 blog posts + 50 mock interviews.
Note: That full path is ~18–24 months of aggressive, consistent work. If you speed up, you can compress phases, but expect heavy workload.
Average target: 8 hours/day sustainable (you said 15/day doable — I don’t advise 15/day long-term).
Weekdays
- 1.5–2 hr DSA (topic + one problem).
- 2.0–3.0 hr JS/React learning + exercises.
- 1.5–2.0 hr Project work (feature implementation).
- 0.5–1.0 hr GitHub / documentation / small tests.
- 0.5 hr review (error logs, previous mistakes).
Weekends
- 3–4 hr deep DSA (timed mock).
- 3–6 hr larger project features & deploy tasks.
- 1–2 hr reading system design / blog writing.
- Frontend + Backend: stick with JavaScript/TypeScript (React + Node) — fastest to build full-stack.
- DSA interviews: Stick with Java (you know it); it’s acceptable for FAANG. C++ gives micro advantage in CP but not necessary. Only switch to C++ if you want to dominate CF problems regularly.
- When to use Python: good for prototyping and some interviews, but not needed if you’re comfortable with Java/JS.
- Don’t do Kubernetes/Terraform/Prometheus/Kafka/RAG before you have 2 deployed projects + solid DSA. These are later-phase skills.
- Don’t chase every new tool. Build 2 real deployed projects and tests first.
- Don’t spend >2 weeks on CSS animations — focus on functionality and polish.
- Start applying as soon as Project A + 150 DSA problems are done (end of Phase 1). Apply to internships & junior SDE roles.
- Target list: product startups, mid-size product companies, top small FAANG-like companies for internships.
- Application tempo: 5–15 applications/day until interviews convert.
- Interview prep: 2 weeks before scheduled interviews drop your learning focus and do daily timed LeetCode + mock interviews with peers.
End Phase 1 (Feb 28, 2026):
- Live portfolio.
- Project A (deployed).
- GitHub with 150 DSA problems.
- 1 solid resume + LinkedIn ready.
End Phase 2 (Jun 30, 2026):
- REST API + DB deployed.
- First internship interviews done.
- 250 DSA problems solved.
End Phase 3 (Dec 31, 2026):
- Flagship Project B deployed (microservices/CI/Redis).
- OSS contributions started.
- Hackathon wins/mentions (1–2).
- 350–400 DSA problems.
End Phase 5 (Jun 30, 2028):
- Multiple interviews cleared, targeted offers, system design strong.
- DSA: LeetCode, GeeksforGeeks (your course), NeetCode, Blind 75.
- Frontend: MDN docs, React docs, Next.js docs, Udemy React courses you own.
- Backend: ZTM Node course (you have), Jonas Schmedtmann Node bootcamp.
- DB/ORM: Postgres docs, Prisma docs, MongoDB docs.
- TS: TypeScript Handbook.
- Docker/AWS: Docker docs; AWS Free Tier tutorials.
- Testing: Jest docs; Supertest; Playwright/Cypress.
- System design: Gaurav Sen (YouTube), Designing Data-Intensive Applications.
- RAG/vector: LangChain docs, pgvector docs (only if pursuing AI product role).
- Do Priority A perfectly. Don’t half-learn things. A solid deployed project + TS + tests + DSA = 80% of hires.
- Consistency beats intensity. 6–8 hrs/day sustained for 18 months > 15 hrs/day for 3 months then burnout.
- Apply early and often. Don’t wait for everything to be perfect to apply for internships from Mar 2026 onward.
- Measure weekly: projects progress, DSA total solved, mock interview count.
- If you want my help next: I will convert this into a week-by-week 12-month execution plan (file names, Git branches, exact LeetCode problems per day), or a compact resource pack. Tell me which now — I’ll produce it immediately.
Say yes to the 12-month week-by-week plan immediately and precisely — no waiting.