Part 52: The Interleaved Learning Schedule
Every Course Ranked by Importance. Then Woven Together.
← Back to Master Index ← Part 51: Full 200+ Course Directory
[!IMPORTANT] The problem with topic-by-topic learning: You spend 4 weeks on Python → forget it during 4 weeks on Docker → forget Docker during 4 weeks on AWS. This is called blocked practice and it's the worst way to learn.
The solution: Interleaved learning. Switch between 2–3 complementary topics daily. Your brain is forced to retrieve knowledge from multiple contexts — the same mechanism that drives long-term retention.
The result: A 40–50% improvement in long-term retention (Journal of Applied Cognitive Psychology, MIT studies, 2024). This part gives you the exact schedule.
The Core Principle: Why Interleaving Works
Blocked Practice (❌ Wrong):
Week 1–4: Python Python Python Python Python Python Python
Week 5–8: Docker Docker Docker Docker Docker Docker Docker
Week 9–12: AWS AWS AWS AWS AWS AWS AWS AWS AWS AWS AWS
Interleaved Practice (✅ Right):
Mon: Python (core) → builds language muscle
Tue: Git + Linux → immediately apply Python to Git hooks
Wed: Python (advanced) → deeper now with Git context
Thu: Docker → containerize your Python scripts
Fri: FastAPI → build APIs in Python, run in Docker
Sat: Project day → full-stack Python + Docker + FastAPI
Sun: Review + Anki cards → spaced repetition lock-in
Why the second path wins: Every time you switch topics, your brain encodes the relationship between subjects, not just the subject itself. Python becomes more meaningful because you immediately use it in Git hooks, then FastAPI, then Docker. Each domain provides context for every other domain.
Step 1: The Importance Master Ranking
Before building the schedule, every course from Parts 27 & 51 is ranked by a single metric: career ROI — the combination of salary impact + job market demand + foundational leverage (how many other skills depend on this one).
Tier 1: Non-Negotiable (Rank 1–20)
These are the 20 courses that directly determine whether you get hired at ₹20–40 LPA roles. Skip any of these and your application will die at the resume screen.
| Rank | Course | Domain | Why It's #1 Tier |
|---|---|---|---|
| 1 | 100 Days of Code (Angela Yu) | Python | Python is the common thread in backend, AI, and DevOps. Without Python, nothing else works. 300K+ reviews. |
| 2 | Git & GitHub Bootcamp (Colt Steele) | Git | You cannot work professionally without Git. Every single job requires it. First day skill. |
| 3 | Linux Command Line Bootcamp (Colt Steele) | Linux | All servers run Linux. Docker runs Linux. AWS runs Linux. Terminal fluency is non-negotiable. |
| 4 | SQL & PostgreSQL: Complete Guide (Grider) | DB | Every backend system has a database. PostgreSQL is the #1 open-source DB in production in 2026. |
| 5 | Docker & Kubernetes: Complete Guide (Grider) | DevOps | Containers are how all modern software ships. No Docker = no deployment. Hiring filter in 2026. |
| 6 | FastAPI Complete Course 2026 | Backend | Python's #1 async web framework. FastAPI + Docker + PostgreSQL = the 2026 backend trifecta. |
| 7 | Redis: Complete Developer's Guide (Grider) | DB | Caching is the difference between 1ms and 1s responses. Redis is the standard. |
| 8 | GitHub Actions: Complete Guide (Schwarzmüller) | CI/CD | Automated pipelines are mandatory. Every job listing says "GitHub Actions experience required." |
| 9 | Ultimate AWS SAA-C03 (Maarek) | Cloud | AWS powers 33% of the internet. Cloud certification = ₹5 LPA salary jump overnight. |
| 10 | Master the Coding Interview: DSA (Neagoie) | DSA | You will not get an interview without passing DSA screens. Period. |
| 11 | Complete GenAI with LangChain (Krish Naik) | AI | AI is the salary multiplier. Knowing LangChain doubles your value vs. a pure backend engineer. |
| 12 | Software Architecture & Large Scale Systems (Pogrebinsky) | Design | System design questions appear in every senior interview. This course is your prep. |
| 13 | Python 3: Deep Dive Part 1 (Fred Baptiste) | Python | Senior Python mastery. Closures, decorators, memory model. Separates junior from mid-level. |
| 14 | MongoDB: Complete Developer's Guide (Schwarzmüller) | DB | Half of all startups use MongoDB. NoSQL is mandatory knowledge. |
| 15 | Apache Kafka Beginners v3 (Maarek) | Messaging | Every distributed system uses event streaming. Kafka is the industry standard. |
| 16 | Build AI Agents with LangGraph (Eden Marco) | AI | Agentic AI is the frontier. LangGraph is the #1 framework for stateful agents in 2026. |
| 17 | Understanding TypeScript (Schwarzmüller) | TypeScript | TypeScript has overtaken JavaScript in production. 87% of Fortune 500 tech teams use it. |
| 18 | Node.js, Express, MongoDB Bootcamp (Schmedtmann) | Node.js | The most complete Node.js backend course. Express + MongoDB in production projects. |
| 19 | Fundamentals of Backend Engineering (Hussein Nasser) | Backend | Protocols, proxies, kernel networking. Separates engineers who build vs. engineers who assemble. |
| 20 | Low-Level Design & SOLID Principles (Prateek Narang) | Patterns | Code review quality. Senior engineers judge you by your design. This course delivers that. |
Tier 2: High Impact (Rank 21–50)
These courses directly expand your salary ceiling and job eligibility. They depend on Tier 1 skills being solid.
| Rank | Course | Domain | Salary Impact |
|---|---|---|---|
| 21 | Kubernetes for Absolute Beginners (Mumshad) | DevOps | CKA certification opens senior DevOps + ₹8–12 LPA roles |
| 22 | Learn Terraform with AWS (Edward Viaene) | IaC | IaC is mandatory in DevOps. Terraform is the standard. |
| 23 | Vector DBs: Fundamentals to Production | AI | RAG systems require vector DB mastery. In every AI job description. |
| 24 | RAG Masterclass: Production Pipelines | AI | RAG is the #1 AI pattern in production. Direct revenue-generating skill. |
| 25 | Python 3: Deep Dive Part 2 (Fred Baptiste) | Python | Generators + async. Foundation for high-performance Python services. |
| 26 | Ultimate AWS Developer Associate (Maarek) | Cloud | Second AWS cert. Developer-specific: Lambda, DynamoDB, CI/CD. |
| 27 | The Complete Agentic AI Engineering Course | AI | Multi-agent + MCP is the next 3-year hiring wave. Get ahead now. |
| 28 | PostgreSQL Bootcamp 60+hrs | DB | Deep PostgreSQL: CTEs, window functions, PL/pgSQL, performance. |
| 29 | Kafka Streams for Data Processing (Maarek) | Messaging | Real-time stream processing. Needed for data-heavy systems. |
| 30 | Docker Mastery: Kubernetes + Swarm (Bret Fisher) | DevOps | Production containers from a Docker Captain. Beyond basics. |
| 31 | CKA: Certified Kubernetes Administrator (Mumshad) | DevOps | CKA is a ₹25–35 LPA cert in 2026. |
| 32 | Master LLM Engineering: Build 14 Projects | AI | Portfolio builder. 14 real AI projects for interview demonstrations. |
| 33 | System Design Masterclass (Frank Kane) | Design | Interview format-specific. FAANG system design patterns. |
| 34 | React: Complete Guide (Schwarzmüller) | Frontend | Full-stack requirement. React powers 80% of frontend in 2026. |
| 35 | Complete MCP Masterclass | AI | Model Context Protocol. The hottest 2026 AI infrastructure skill. |
| 36 | Bash Scripting & Shell Programming (Cannon) | Linux | Automation scripts. Every DevOps role requires shell scripting. |
| 37 | The Complete NLP with Transformers | AI | Hugging Face, BERT fine-tuning. ML-adjacent AI engineering. |
| 38 | Observability: Grafana, Prometheus, Loki | Monitoring | Production systems require observability. Every SRE job needs this. |
| 39 | Decoding DevOps — Imran Teli | DevOps | Full DevOps ecosystem. Jenkins, GitLab, Docker, K8s together. |
| 40 | Advanced LangGraph: Multi-Agents | AI | State management, HITL workflows. Senior AI engineer skills. |
| 41 | JavaScript Algorithms & DSA (Colt Steele) | DSA | JS-native DSA for TypeScript/Node engineers in interviews. |
| 42 | Python Data Structures + LeetCode (Scott Barrett) | DSA | Python-native + integrated exercises. Best for Python interview prep. |
| 43 | HashiCorp Terraform Associate 2026 (Zeal Vora) | IaC | Certification + practical Terraform. Bestseller. |
| 44 | Next.js & React: Complete Guide (Schwarzmüller) | Frontend | Full-stack React. App Router, Server Components, auth. |
| 45 | Web Security & Penetration Testing | Security | OWASP Top 10. Required knowledge for backend engineers. |
| 46 | Modern Computer Vision: PyTorch | AI/CV | CV is the second AI frontier after LLMs. YOLOv8, GenAI integration. |
| 47 | Machine Learning A-Z (Eremenko, Ponteves) | ML | Classical ML foundation. Required context for understanding LLMs. |
| 48 | AI Engineer Production Track: Deploy LLMs | MLOps | Production AI deployment. CI/CD for AI systems. |
| 49 | Data Engineering Bootcamp: PySpark + AWS | Data Eng | Data engineering is adjacent to AI. Opens a parallel career track. |
| 50 | Complete Prompt Engineering Bootcamp 2026 | AI | Prompt engineering + LoRA fine-tuning. Fast practical AI skill. |
Tier 3: Deep Specialization (Rank 51–100)
These courses compound your existing skills and open senior
- architect-level roles. Study them after Tier 1 & 2 are solid.
| Rank | Course | Domain |
|---|---|---|
| 51 | Backend Master Class: Go + Postgres + K8s + gRPC | Golang |
| 52 | Advanced NLP: LoRA Fine-Tuning Llama3 | AI |
| 53 | Playwright Python Automation: Zero to Expert | Testing |
| 54 | Mathematical Foundations of Machine Learning | ML Math |
| 55 | PyTorch for Deep Learning Bootcamp | Deep Learning |
| 56 | Kafka Connect Hands-On (Maarek) | Messaging |
| 57 | Python 3: Deep Dive Part 4 — OOP (Fred Baptiste) | Python |
| 58 | CKA Certified Kubernetes Application Developer | DevOps |
| 59 | Mastering AutoGen: Multi-Agent Systems | AI |
| 60 | AI Engineer Bootcamp 2026: LLMs, RAG, Agents | AI |
| 61 | Ultimate Clean Code Masterclass | Architecture |
| 62 | TypeScript Design Patterns & SOLID | Architecture |
| 63 | Prometheus: Complete Hands-On Monitoring | Monitoring |
| 64 | LLMOps & AIOps Bootcamp: 8 Projects | MLOps |
| 65 | REST vs GraphQL vs gRPC: Complete Guide | API Design |
| 66 | TensorFlow for Deep Learning Bootcamp | Deep Learning |
| 67 | Python for Computer Vision with OpenCV | CV |
| 68 | Kafka Cluster Setup & Administration (Maarek) | Messaging |
| 69 | Serverless Architecture Bootcamp V2 | Serverless |
| 70 | AWS Lambda for Python Developers | Serverless |
| 71 | Data Science: Transformers for NLP | NLP |
| 72 | Complete Airflow 3: Hands-On Introduction | Data Eng |
| 73 | SQL Bootcamp: Zero to Hero (Portilla) | DB |
| 74 | Modern API Development: REST+GraphQL+gRPC | API Design |
| 75 | Gen AI RAG with LlamaIndex | AI |
| 76 | Playwright Automation + AI + Jenkins | Testing |
| 77 | Generative AI Engineering: OpenAI + Anthropic | AI |
| 78 | Python: SOLID Principles & Design Patterns | Architecture |
| 79 | Complete Math, Statistics & Probability for ML | ML Math |
| 80 | LangChain: Develop LLM Apps | AI |
| 81 | Databricks Data Engineering 2026 | Data Eng |
| 82 | Build 15+ Real-Time Deep Learning CV Projects | CV |
| 83 | Advanced Python: Real-World Deep Dive 2026 | Python |
| 84 | Microservices: Clean Architecture + DDD + Kafka | Architecture |
| 85 | Mastering Authentication: JWT, SSO (Node.js) | Security |
| 86 | Working with Microservices in Go | Golang |
| 87 | Unit Testing & TDD in Python | Testing |
| 88 | MongoDB Administration Guide | DB |
| 89 | Redis: From Beginner to Advanced (22h) | DB |
| 90 | LangChain Mastery: Pinecone + RAG | AI |
| 91 | Building Fullstack Serverless Apps on AWS | Serverless |
| 92 | Python Concurrency with asyncio | Python |
| 93 | Mastering Prometheus and Grafana Stack | Monitoring |
| 94 | OWASP Top 10:2025 Comprehensive Training | Security |
| 95 | Python Data Science + ML Bootcamp (Portilla) | ML |
| 96 | Linux Shell Scripting: Project-Based (Cannon) | Linux |
| 97 | Terraform for Absolute Beginners with Labs | IaC |
| 98 | Deep Learning A-Z 2026 (Eremenko) | Deep Learning |
| 99 | Complete Python Developer: Zero to Mastery | Python |
| 100 | A Deep Understanding of LLM Mechanisms (Cohen) | AI |
Step 2: The Interleaved Weekly Schedule
[!NOTE] How to read this schedule: Each week shows 3 active "tracks" being studied simultaneously. You do NOT finish one before starting the next. You alternate daily. The tracks are chosen because they reinforce each other — concepts from Track A make Track B click faster.
The Interdependency Map
Python ──────────────────────────────► FastAPI
│ │
├──► Git (version control) ├──► Docker
│ │
├──► Linux (environment) ├──► PostgreSQL
│ │
└──► DSA (problem solving) └──► LangChain
│
AWS ◄────────────────────────── Kafka ◄────────┤
│ │ │
├──► Terraform │ ├──► LangGraph
│ │ │
├──► Docker (ECR/ECS) └──► Redis └──► RAG/Vectors
│
└──► GitHub Actions (CI/CD)
Each connecting line = skills that use each other. Learning them simultaneously makes both stick faster.
The 52-Week Interleaved Plan
Phase 1: Foundations (Weeks 1–8)
Three tracks active simultaneously
🗓️ Week 1–2: Python × Git × Linux
Why this trio?
- Python gives you code to version-control
- Git teaches you to manage that Python code
- Linux is where Python and Git run
| Day | Morning (1.5h) | Evening (1.5h) | Project |
|---|---|---|---|
| Mon | Python: Angela Yu — Days 1–10 | Git: Colt Steele — Sections 1–4 | Create Python script, commit to GitHub |
| Tue | Python: Days 11–20 | Linux: Colt Steele — Sections 1–5 | Run Python in a Linux terminal |
| Wed | Python: Days 21–30 | Git: Sections 5–8 (branching) | Feature branches for Python project |
| Thu | Python: Days 31–40 | Linux: Sections 6–10 (permissions) | Set up Python venv on Linux |
| Fri | Python: Days 41–50 | Git: Sections 9–12 (remotes, PRs) | Open source contribution flow |
| Sat | 3h Project: Build a CLI tool in Python, host on GitHub | ||
| Sun | Review: Anki cards for Python syntax + Git commands |
Ranks studied: Python (#1), Git (#2), Linux (#3)
Cross-reinforcement: Python scripts → Git commits → Linux environment → back to Python. The loop is immediate and tangible.
🗓️ Week 3–4: PostgreSQL × FastAPI × Docker
Why this trio?
- PostgreSQL is the data store
- FastAPI is the API layer that reads from PostgreSQL
- Docker is how you run both together
| Day | Track A (2h) | Track B (1h) | Connection |
|---|---|---|---|
| Mon | PostgreSQL: Grider Ch 1–4 (tables, CRUD) | FastAPI: Setup + first endpoint | FastAPI endpoint reads from PG |
| Tue | PostgreSQL: Ch 5–7 (joins, aggregates) | Docker: Containers 101 | Dockerize PostgreSQL + FastAPI |
| Wed | PostgreSQL: Ch 8–10 (indexes, performance) | FastAPI: SQLAlchemy + Pydantic | ORM maps PG schema to FastAPI models |
| Thu | PostgreSQL: Ch 11–13 (transactions) | Docker: Volumes + networks | PG data persists in Docker volumes |
| Fri | FastAPI: Auth + JWT + middleware | Docker Compose | Compose up: API + DB + Redis |
| Sat | Build: REST API for a bookstore — FastAPI + PG + Docker Compose | ||
| Sun | Review: ER diagrams, Pydantic models, Dockerfile patterns |
Ranks studied: PostgreSQL (#4), FastAPI (#6), Docker (#5, partial)
Cross-reinforcement: You can't build the API without the database. You can't run the API without Docker. They force each other into context.
🗓️ Week 5–6: Docker (deep) × Redis × GitHub Actions
Why this trio?
- Docker needs a registry + CI to push images
- Redis lives in Docker as a sidecar
- GitHub Actions builds and pushes Docker images
| Day | Track A (2h) | Track B (1h) | Build |
|---|---|---|---|
| Mon | Docker: Multi-stage builds, ECR | Redis: Data types, sorted sets | Redis sidecar in Docker Compose |
| Tue | Docker: Networking, health checks | GitHub Actions: First workflow | Auto-build Docker on push |
| Wed | Docker: Kubernetes intro | Redis: Pub/Sub, streams | Redis + FastAPI caching layer |
| Thu | GitHub Actions: Secrets, matrix tests | Redis: TTL, eviction policies | CI runs tests with Redis service |
| Fri | Docker: Production hardening | GitHub Actions: Deploy workflow | CD pushes to AWS ECR |
| Sat | Build: Full CI/CD pipeline — test, build, push Docker image to AWS ECR | ||
| Sun | Review: YAML syntax, Docker networking, Redis commands |
Ranks studied: Docker (#5), Redis (#7), GitHub Actions (#8)
🗓️ Week 7–8: AWS × Python Deep Dive × DSA Warm-Up
Why this trio?
- AWS is where your Docker containers run in production
- Python Deep Dive strengthens the language you deploy
- DSA Warm-Up starts interview prep — never start late
| Day | Track A (1.5h) | Track B (1h) | Track C (0.5h) |
|---|---|---|---|
| Mon | AWS SAA: IAM, EC2, S3 | Python Deep Dive: Memory model, scopes | LeetCode: 2 Easy problems |
| Tue | AWS SAA: VPC, subnets, security groups | Python Deep Dive: First-class functions | LeetCode: Arrays & Hashing |
| Wed | AWS SAA: RDS, ElastiCache | Python Deep Dive: Closures, decorators | LeetCode: Two Pointers |
| Thu | AWS SAA: Lambda, API Gateway | Python Deep Dive: Generators, iterators | LeetCode: Sliding Window |
| Fri | AWS SAA: ECS, ECR, Fargate | Python Deep Dive: Context managers | LeetCode: Stacks |
| Sat | Deploy Week 3–6 project to AWS ECS with CDN | ||
| Sun | Review: AWS architecture diagrams + LeetCode patterns flashcards |
Ranks studied: AWS (#9), Python Deep Dive (#13), DSA (#10, warm-up)
Phase 2: Integration (Weeks 9–20)
Skills now interlock across all Phase 1 foundations
🗓️ Week 9–10: Kafka × MongoDB × DSA (Trees/Graphs)
Why this trio?
- Kafka produces events; MongoDB stores them
- DSA Trees/Graphs = the algorithms behind Kafka partition trees + MongoDB index B-trees
| Day | Morning | Evening | DSA (30 min) |
|---|---|---|---|
| Mon | Kafka: Topics, partitions, producers | MongoDB: Documents, CRUD | Binary Trees — DFS/BFS |
| Tue | Kafka: Consumers, consumer groups | MongoDB: Aggregation pipeline | Binary Search Tree |
| Wed | Kafka: Kafka Streams | MongoDB: Indexes, performance | Heaps & Priority Queues |
| Thu | Kafka: Schema Registry + Avro | MongoDB: Replica sets | Graphs — BFS |
| Fri | Connect Kafka → MongoDB (sink connector) | MongoDB: Atlas Search | Graphs — DFS |
| Sat | Build: IoT sensor data pipeline — Kafka → consumer → MongoDB | ||
| Sun | Review: Kafka offset management + MongoDB aggregation cheat sheet |
Ranks studied: Kafka (#15), MongoDB (#14), DSA (#10, 41, 42)
🗓️ Week 11–12: LangChain × Python Deep Dive Part 2 × System Design Intro
Why this trio?
- LangChain is written in Python — Part 2 generators power async chains
- System Design thinking makes LangChain architecture make sense
| Day | AI Track (2h) | Python Track (1h) | System Design (30 min) |
|---|---|---|---|
| Mon | LangChain: LLMs, prompts, chains | Generators, lazy evaluation | URL shortener design |
| Tue | LangChain: Memory, conversation history | Async generators | Twitter feed design |
| Wed | LangChain: RAG — loaders, splitters | Context managers | Rate limiter design |
| Thu | LangChain: Retrieval chains | Decorators advanced | Chat system design |
| Fri | LangChain: Agents, tool calling | Closures + functools | Notification system |
| Sat | Build: LangChain chatbot over your own docs, hosted on FastAPI + Docker | ||
| Sun | Review: System design vocab flashcards + LangChain chain types |
Ranks studied: LangChain (#11), Python Part 2 (#25), System Design (#12)
🗓️ Week 13–14: TypeScript × Node.js × DSA (Dynamic Programming)
Why this trio?
- TypeScript is typed JavaScript — learn it while building Node.js APIs
- DP problems appear in TypeScript/JS company interviews specifically
| Day | Track A (2h) | Track B (1h) | DSA (30 min) |
|---|---|---|---|
| Mon | TypeScript: Types, interfaces, generics | Node.js: Event loop internals | DP — Fibonacci, climb stairs |
| Tue | TypeScript: Decorators, namespaces | Node.js: Express middleware | DP — Knapsack problem |
| Wed | TypeScript: Advanced types (conditional) | Node.js: Streams, buffers | DP — LCS |
| Thu | TypeScript: Mixins, declaration merging | Node.js: Worker threads | DP — Edit distance |
| Fri | TypeScript: Build tooling, tsconfig | Node.js: Clustering, PM2 | DP — Coin change |
| Sat | Build: TypeScript + Express REST API with full type safety + deployed with PM2 | ||
| Sun | Review: TypeScript cheat sheet, Node event loop diagram |
Ranks studied: TypeScript (#17), Node.js (#18), DSA — DP track
🗓️ Week 15–16: Terraform × AWS Developer × Kafka Deep
Why this trio?
- Terraform provisions the AWS infrastructure
- AWS Developer teaches Lambda + DynamoDB that Kafka triggers
- Together they form a full event-driven serverless architecture
| Day | IaC Track (1.5h) | Cloud Track (1.5h) | Kafka Track (1h) |
|---|---|---|---|
| Mon | Terraform: Providers, state, plan/apply | AWS DVA: IAM programmatic access | Kafka Streams: KTables |
| Tue | Terraform: Modules, variables | AWS DVA: Lambda functions | Kafka: Exactly-once semantics |
| Wed | Terraform: Remote state (S3 backend) | AWS DVA: DynamoDB | Kafka: Schema Registry |
| Thu | Terraform: Workspace environments | AWS DVA: API Gateway | Kafka: Connect (sink to S3) |
| Fri | Terraform: Terragrunt (DRY configs) | AWS DVA: CodePipeline | Kafka: Monitoring & alerting |
| Sat | Provision: Lambda + DynamoDB + API Gateway + S3 using Terraform | ||
| Sun | Review: Terraform state locking, AWS Lambda cold starts, Kafka lag monitoring |
Ranks studied: Terraform (#22), AWS Dev (#26), Kafka (#15, 29)
🗓️ Week 17–18: LangGraph × RAG & Vectors × Hussein Nasser Backend
Why this trio?
- LangGraph agents need RAG pipelines to retrieve knowledge
- Hussein Nasser explains why the HTTP/TCP layer works — critical for debugging AI API calls
| Day | Agent Track (2h) | Vector Track (1h) | Network Track (30 min) |
|---|---|---|---|
| Mon | LangGraph: State machines, nodes, edges | ChromaDB — embeddings, similarity | HTTP/1.1 vs HTTP/2 |
| Tue | LangGraph: Conditional edges, branching | Pinecone — managed vector store | TCP handshakes, keep-alive |
| Wed | LangGraph: Multi-agent supervisor | Hybrid search (BM25 + vectors) | Proxies: forward vs reverse |
| Thu | LangGraph: HITL (human-in-the-loop) | Chunking strategies | Load balancing algorithms |
| Fri | LangGraph: Streaming outputs | RAGAS evaluation | gRPC vs REST vs WebSocket |
| Sat | Build: Customer support agent — LangGraph + RAG over product docs, deployed on FastAPI | ||
| Sun | Review: LangGraph state schema + RAGAS metrics + TCP diagram |
Ranks studied: LangGraph (#16), RAG/Vectors (#23, 24), Backend Fundamentals (#19)
🗓️ Week 19–20: Kubernetes Deep × Observability × SOLID Patterns
Why this trio?
- Kubernetes deployments break — Observability tells you why
- SOLID/Clean Code determines whether K8s config is maintainable
| Day | K8s Track (2h) | Observability (1h) | Architecture (30 min) |
|---|---|---|---|
| Mon | K8s: Pods, ReplicaSets, Deployments | Prometheus: PromQL basics | Single Responsibility Principle |
| Tue | K8s: Services, Ingress, DNS | Grafana: Dashboards, alerting | Open/Closed Principle |
| Wed | K8s: ConfigMaps, Secrets, RBAC | Loki: Log aggregation | Liskov Substitution |
| Thu | K8s: StatefulSets (for databases) | Tempo: Distributed tracing | Interface Segregation |
| Fri | K8s: HPA, resource limits | OpenTelemetry setup | Dependency Inversion |
| Sat | Deploy full stack on K8s: FastAPI + PG + Redis + monitoring | ||
| Sun | Review: K8s troubleshooting commands, SOLID refactoring exercise |
Ranks studied: K8s (#21, 31), Observability (#38), SOLID (#20)
Phase 3: AI Engineering (Weeks 21–32)
All backend + DevOps skills now serve as infrastructure for AI systems
🗓️ Week 21–22: Full GenAI Stack × MCP × Security
Why this trio?
- GenAI (Krish Naik) builds the system
- MCP connects it to tools
- Security protects it — AI systems are high-value targets
| Day | GenAI Track (2h) | MCP Track (1h) | Security (30 min) |
|---|---|---|---|
| Mon | GenAI: LLM APIs, token management | MCP: Client-server architecture | OWASP A01: Broken Access |
| Tue | GenAI: Embeddings, vector stores | MCP: Build a database MCP server | OWASP A02: Crypto failures |
| Wed | GenAI: RAG pipeline from scratch | MCP: STDIO transport layer | JWT anatomy, RS256 vs HS256 |
| Thu | GenAI: Chatbot with memory | MCP: SSE transport, auth | OAuth 2.0 PKCE flow |
| Fri | GenAI: Deploy to production | MCP: Docker containerization | Rate limiting, DDoS basics |
| Sat | Build: Production RAG app with MCP-connected database, secured with OAuth | ||
| Sun | Review: LLM token math + MCP JSON-RPC + OWASP checklist |
Ranks studied: GenAI (#11), MCP (#35), Security (#45)
🗓️ Week 23–24: Multi-Agent (CrewAI/AutoGen) × LoRA Fine-Tuning × DSA (Final push)
Why this trio?
- Multi-agent systems are stateful programs — DSA thinking makes orchestration design natural
- LoRA fine-tuning is how you customize the LLMs your agents use
| Day | Agent Track (2h) | Fine-Tune Track (1h) | DSA (30 min) |
|---|---|---|---|
| Mon | CrewAI: Agents, tasks, crew creation | LoRA: PEFT library basics | Backtracking algorithms |
| Tue | CrewAI: Tools, memory, sequential flow | LoRA: Dataset preparation | Tries |
| Wed | AutoGen: Conversational agents | LoRA: Training on GPU | Segment trees |
| Thu | AutoGen: Group chat, code execution | LoRA: RLHF fundamentals | Union-Find |
| Fri | Agent orchestration: CrewAI + LangGraph | QLoRA: 4-bit quantization | LeetCode mock interview |
| Sat | Build: Research agent team — planner + researcher + writer + critic | ||
| Sun | Mock Interview: 45-min DSA session + 30-min system design |
Ranks studied: Multi-agent (#27), LoRA/Fine-tuning (#50, 52), DSA (final)
🗓️ Week 25–26: MLOps × Production AI Deployment × Golang Intro
Why this trio?
- MLOps deploys AI models the same way DevOps deploys apps
- Golang is what high-performance AI infrastructure services are written in
| Day | MLOps Track (2h) | Golang Track (1h) | |
|---|---|---|---|
| Mon | LLMOps: Model versioning, A/B testing | Go: Types, interfaces, goroutines | |
| Tue | LLMOps: CI/CD for LLMs | Go: Channels, select, WaitGroups | |
| Wed | LLMOps: LangSmith observability | Go: HTTP server, JSON APIs | |
| Thu | MLOps: Docker + K8s for model serving | Go: gRPC server | |
| Fri | MLOps: Vector DB scaling, cost analysis | Go: Connect gRPC to AI service | |
| Sat | Deploy: FastAPI LLM service + Go gRPC sidecar + K8s + monitoring | ||
| Sun | Review: gRPC proto files + LangSmith traces analysis |
Ranks studied: MLOps (#48), Golang (#51)
🗓️ Week 27–28: Data Engineering × NLP Transformers × System Design Deep
Why this trio?
- Data Engineering pipelines feed data to both ML training and RAG retrieval
- NLP Transformers explain the models your agents use
- System Design is intensifying — senior interviews are approaching
| Day | Data Eng (1.5h) | NLP Track (1h) | System Design (1.5h) |
|---|---|---|---|
| Mon | Airflow: DAGs, operators | BERT architecture | Design YouTube |
| Tue | PySpark: DataFrames, transformations | Hugging Face pipelines | Design Netflix |
| Wed | ETL: Extract from APIs, load to S3 | Fine-tune BERT for classification | Design Uber |
| Thu | Delta Lake: ACID, time travel | T5, summarization | Design WhatsApp |
| Fri | dbt: transform layer | GPT-2 from scratch (PyTorch) | Design Instagram |
| Sat | Build: ELT pipeline — API → Airflow → PySpark → Delta Lake → RAG index | ||
| Sun | System Design mock: 45 mins, record yourself, review |
Ranks studied: Data Eng (#49), NLP (#37), System Design (#12, 33)
🗓️ Week 29–30: React/Next.js × TypeScript Advanced × REST/GraphQL/gRPC
Why this trio?
- React/Next.js is the frontend for your AI apps
- TypeScript Advanced makes React type-safe
- API Design bridges your frontend to your FastAPI/Node.js backend
| Day | Frontend Track (2h) | API Design (1h) | |
|---|---|---|---|
| Mon | React: Hooks deep dive, custom hooks | REST: OpenAPI design-first | |
| Tue | Next.js: App Router, Server Components | GraphQL: Schema, resolvers | |
| Wed | Next.js: Server Actions, data fetching | gRPC: Protobuf definitions | |
| Thu | Next.js: Auth (Auth.js + OAuth) | API versioning strategies | |
| Fri | Next.js: Deploy to Vercel + custom domain | API gateway patterns | |
| Sat | Build: Full-stack Next.js AI app — frontend calls FastAPI AI backend | ||
| Sun | Review: Next.js rendering modes + GraphQL vs REST decision matrix |
Ranks studied: React/Next.js (#34, 44), API Design (#65, 74)
🗓️ Week 31–32: Computer Vision × Testing & TDD × Clean Architecture
Why this trio?
- CV uses the same Python + PyTorch stack as LLMs
- Testing ensures your CV and AI pipelines don't break in production
- Clean Architecture makes all three maintainable
| Day | CV Track (2h) | Testing Track (1h) | Architecture (30 min) |
|---|---|---|---|
| Mon | Modern CV: OpenCV, image processing | pytest: Fixtures, parametrize | Repository pattern |
| Tue | Modern CV: CNNs, feature detection | pytest: Mocking, monkeypatching | Service layer pattern |
| Wed | CV: YOLOv8 object detection | Playwright: Locators, wait strategies | CQRS pattern |
| Thu | CV: CLIP multimodal models | Playwright: Page Object Model | Event sourcing basics |
| Fri | CV: CV + LLM (GPT-4V style) | CI: Run tests in GitHub Actions | Hexagonal architecture |
| Sat | Build: CV pipeline — object detection service, fully tested, clean architecture | ||
| Sun | Review: pytest conftest patterns + YOLO config + hexagonal arch diagram |
Ranks studied: CV (#46), Testing (#53, 76), Clean Architecture (#61)
Phase 4: Interview Sprint (Weeks 33–40)
[!CAUTION] From Week 33 onward, no new courses start. You are now in interview prep mode. All courses already started continue as review sessions. New material is limited to interview-specific content.
🗓️ Week 33–36: DSA Intensive × System Design × Behavioral
The 4-week interview engine.
| Day | DSA (2h) | System Design (1.5h) | Behavioral (30 min) |
|---|---|---|---|
| Mon | LeetCode: 3 Medium problems | Design a system from scratch | STAR story: leadership |
| Tue | Pattern review: Which pattern fits? | Estimate capacity (QPS, storage) | STAR story: conflict |
| Wed | LeetCode: 1 Hard problem | Draw architecture (whiteboard) | STAR story: failure |
| Thu | Weekly contest (LeetCode) | Deep-dive: Database choices | STAR story: achievement |
| Fri | Review failures from Tue/Wed | Review: Availability vs Consistency | Mock 30-min behavioral |
| Sat | Full mock interview: 1h DSA + 1h System Design (with a peer) | ||
| Sun | Anki: All flashcards for week's topics |
Target by Week 36:
- 200+ LeetCode problems solved
- 10 system designs designed from scratch
- 5 STAR behavioral stories polished
🗓️ Week 37–38: Company Research × Applied AI Projects × Resume Polish
| Day | Task | |
|---|---|---|
| Mon | Apply to 10 companies. Research top 3 deeply | |
| Tue | Build: AI-enhanced version of a past project | |
| Wed | Resume: Quantify every bullet (₹, %, ms improvements) | |
| Thu | LinkedIn: Connection requests to 20 engineers at target companies | |
| Fri | GitHub: README for every project, clean commit history | |
| Sat | Referral outreach: personalized messages to 5 connections | |
| Sun | Rest + Anki review |
🗓️ Week 39–40: Mock Interviews × Offer Negotiation Prep
| Day | Task |
|---|---|
| Mon | Pramp mock interview: 1h DSA |
| Tue | Peer mock: 1h System Design |
| Wed | Salary research: glassdoor + levels.fyi for target companies |
| Thu | Negotiation course: watch Salary Negotiation Pro Masterclass |
| Fri | Offer letter read-through: base + bonus + stock + benefits math |
| Sat | Send follow-ups to every pending application |
| Sun | Final mock: Full 2h interview simulation |
Phase 5: Specialization & Depth (Weeks 41–52)
After landing the job or during the job, continue deepening expertise.
🗓️ Week 41–44: Specialization Track A — AI/LLM Engineer
For those targeting AI engineer roles (₹25–50 LPA).
| Week | Primary Course | Secondary Course | Build |
|---|---|---|---|
| 41 | Advanced LangGraph: Sub-graphs, HITL | Generative AI Eng: OpenAI + Anthropic | Agentic customer support system |
| 42 | LLMOps: Model evaluation pipelines | Prometheus: AI service monitoring | Production monitoring dashboard |
| 43 | Fine-tuning: QLoRA on custom dataset | Vector DB scaling: Pinecone v3 | Domain-specific RAG system |
| 44 | MCP: Advanced server — OAuth + Docker | AI Engineer Bootcamp: Final projects | Portfolio: 5 deployed AI projects |
🗓️ Week 41–44: Specialization Track B — Backend/Distributed Systems
For those targeting senior backend roles (₹20–35 LPA).
| Week | Primary Course | Secondary Course | Build |
|---|---|---|---|
| 41 | Backend Master Class: Go + gRPC | Kafka Deep: Streams + Kafka Connect | Go microservice with Kafka events |
| 42 | Microservices: DDD + SAGA + Outbox | CKA: K8s admin certification prep | Multi-service K8s deployment |
| 43 | Data Engineering: Airflow + Databricks | Terraform: Multi-region infra | Data lake on AWS with Terraform |
| 44 | Observability: Full LGTM stack | System Design: 10 more case studies | Full production observability setup |
🗓️ Week 45–48: Fill the Gaps
Use these weeks for whichever Tier 3 courses you haven't touched, based on where your upcoming interviews are pointing.
Quick reference — match to your interview type:
| Interview Type | Courses to Focus On |
|---|---|
| FAANG-style | DSA hard problems, System Design (Pogrebinsky), Clean Code |
| AI startup | LLMOps, Fine-tuning, MCP, Agentic AI Engineering |
| DevOps/SRE | CKA, Terraform, Prometheus deep, Kubernetes admin |
| Data Engineering | Airflow, Databricks, PySpark, dbt |
| Full-stack startup | Next.js, React, TypeScript, Node.js advanced |
🗓️ Week 49–52: The Long Game
By this point you've consumed 60–80 courses across all tiers. These final 4 weeks are pure deliberate practice and consolidation.
| Week | Focus |
|---|---|
| 49 | Teach what you know: write blog posts explaining 5 complex topics |
| 50 | Open source: contribute to LangChain, FastAPI, or Kafka repos |
| 51 | Review: Go back to first principles courses, see what lands differently |
| 52 | Plan Year 2: Set salary target, identify the skill that will unlock it |
The Daily Study Blueprint
Regardless of phase or week, this is how each day looks:
┌─────────────────────────────────────────────────────┐
│ 6:00–6:30 │ Anki flashcard review (30 min) │
│ │ (spaced repetition, yesterday's cards) │
├─────────────┼───────────────────────────────────────┤
│ 6:30–8:00 │ TRACK A — Primary topic │
│ │ (the harder, more important course) │
├─────────────┼───────────────────────────────────────┤
│ 8:00–8:30 │ Commute / breakfast break │
├─────────────┼───────────────────────────────────────┤
│ 20:00–21:30│ TRACK B — Secondary topic │
│ │ (the complementary, reinforcing course)│
├─────────────┼───────────────────────────────────────┤
│ 21:30–22:00│ Project work or LeetCode (1 problem) │
├─────────────┼───────────────────────────────────────┤
│ 22:00–22:15│ Make Anki cards for today's new │
│ │ concepts. Review tomorrow morning. │
└─────────────┴───────────────────────────────────────┘
Total: 3.5h/day × 6 days + 4h Sunday = ~25h/week
The Interleaving Rules
Follow these rules and your retention will dramatically outperform any friend doing traditional blocked learning:
Rule 1: Never watch more than 2 consecutive lectures on one topic Switch before your brain gets comfortable. Comfort = no retrieval challenge = no long-term encoding.
Rule 2: Always connect today's new concept to yesterday's different topic At the start of each session, spend 5 minutes asking: "How does [Track B from yesterday] relate to [Track A today]?" Write one sentence. This forces encoding of the relationship.
Rule 3: Prefer confusion over comfort If a section feels too easy, you're either ahead or not being challenged enough. Increase difficulty or switch to a harder complementary track.
Rule 4: Build something every single week Passive watching = 10% retention. Building = 90% retention. The project is not optional. It IS the learning.
Rule 5: Practice retrieval, not re-watching If you forget something, DON'T re-watch the lecture first. Try to recall it for 5 minutes. Then look it up. This retrieval struggle is where learning happens.
Course Acquisition Strategy
| Priority | Action |
|---|---|
| First | Check TCS Udemy Business (free for TCS employees) |
| Second | Check LinkedIn Learning (Infosys/Wipro provide access) |
| Third | Wait for Udemy sale (₹399–599). Never pay full price. |
| Monthly cap | Buy max 3 courses/month. Focus beats breadth. |
| Subscription | Udemy Personal Plan (₹850/mo) if taking 4+ courses |
← Part 51: Full 200+ Course Directory
Part 27: Original Udemy Course Arsenal →
Last updated: June 3, 2026
Comments
Comments are powered by giscus. Set
PUBLIC_GISCUS_REPO_IDandPUBLIC_GISCUS_CATEGORY_IDin your environment to enable them.