About the Program
This is a structured 6-month certification program designed to transform you from a strong foundational learner into a confident, industry-ready engineer. Instead of learning concepts in isolation, it follows a connected progression—from mathematical thinking to core programming, and finally to advanced AI and LLM systems—reflecting how real-world products are engineered. There are three courses running in parallel, designed to reinforce each other. Mathematical intuition strengthens coding skills, coding enables AI implementation, and AI projects bring everything together into real systems.
Who can join?
- Graduates struggling to secure roles in software engineering or AI
- Professionals seeking to integrate modern AI tools like LLMs into their workflows
- BS (CS/SE/AI/Data Science) students who have completed at least 2 years of study
Whether you are beginning your journey, preparing to enter the job market, or upgrading your technical depth, it provides a clear pathway to move from fundamentals to real engineering competence in the age of AI.

Who can join?
BS (CS/SE/AI/Data Science) students who have completed at least 2 years of study
Graduates and professionals who feel that they need to refresh their mathematical knowledge
Whether you are beginning your journey, preparing to enter the job market, or upgrading your technical depth, this course provides a solid grounding in the four most important areas of mathematics that an AI engineer and algorithm designer needs: Discrete Mathematics, Calculus, Linear Algebra, and Probability.
About The Course
Mathematical Foundations for AI and Algorithmic Thinking is a comprehensive course designed to build the core mathematical intuition required for Artificial Intelligence, Machine Learning, and advanced algorithms.
Master the mathematical pillars of AI—Discrete Mathematics, Calculus, Probability, and Linear Algebra. Learn to transform abstract formulas into practical tools for building intelligent technology. Explore the ideas behind intelligent systems through hands-on mathematical modeling connecting theory to neural networks, optimization, probabilistic learning, and high-dimensional data. This journey is designed to turn mathematical principles into clarity, confidence, and creative problem-solving, whether your path leads to Machine Learning, Data Science, competitive programming, or AI research.
Module 1: Discrete Mathematics for AI
Lecture 1 — Foundations of Logic, Proofs & Sets
- Core Concepts: Propositions, truth tables (AND, OR, XOR, NOT), logical implication, equivalence, and quantifiers (∀, ∃). Direct proofs vs. contradiction. Proof of the prime factor bound — why checking divisors only up to √N is sufficient.
- Intuition: Building the “grammar” of mathematics to define truth and falsehood clearly.
- AI/CS Link: Logical rules form the basis of rule-based systems; quantifiers define model assumptions.
Lecture 2 — Mathematical Induction & Recurrence Relations
- Core Concepts: The principle of mathematical induction, induction on sequences, and relating recursion to induction. Key proofs:
- Arithmetic Series: sum = n(n+1)/2
- Geometric Series: sum = a(rⁿ−1)/(r−1) and their practical impact
- Intuition: Using a “domino effect” logic to prove that a property holds for all infinite steps of a process.
- AI/CS Link: Induction is used to prove convergence of iterative algorithms and correctness of recursive functions.
Lecture 3 — Growth Rates & Computational Complexity
- Core Concepts: Big O, Big Theta, and Big Omega notation. Comparing function classes: Constant, Logarithmic, Linear, n log n, Quadratic, Exponential.
- Intuition: Understanding how time/space required by an algorithm scales with input size.
- AI/CS Link: Vital for evaluating scalability of training algorithms and efficiency of model inference.
Lecture 4 — Advanced Set Theory & Relations
- Core Concepts: Set operations, Cartesian products, and power sets.
- Key relation properties: Closure, Transitivity, Symmetry, Reflexivity.
- Intuition: Organizing data into collections and defining how elements within them interact.
- AI/CS Link: Set operations used for dataset splits (train/test/val) and defining feature sets.
Lecture 5 — Counting, Combinatorics & Binomials
- Core Concepts:
- Sum, Product, Subtraction, and Division rules
- Permutations and combinations
- Binomial Theorem
- Inclusion-Exclusion principle and its generalization
- Intuition: Calculating the number of possible outcomes or configurations in a finite system.
- AI/CS Link: Model capacity, parameter search space, and number of possible token sequences in NLP.
Lecture 6 — Graph Theory Foundations
- Core Concepts: Nodes, edges, directed vs. undirected graphs, adjacency matrices, paths, and connectivity.
- Intuition: Representing complex relationships between entities as a network.
- AI/CS Link: Neural networks as computational graphs; knowledge graphs for semantic relationships.
Lecture 7 — Trees, DAGs & Topological Sorting
- Core Concepts:
- Tree structures and Directed Acyclic Graphs (DAGs)
- Topological sorting
- Traversal algorithms: DFS and BFS in grids and general graphs
- Intuition: Modeling hierarchical data and processes with a specific execution order.
- AI/CS Link: Backpropagation is a reverse traversal on a DAG; transformers utilize attention graphs.
Lecture 8 — Formal Languages & Automata for AI
- Core Concepts: Finite State Machines (FSM), regular expressions, and the relationship between logic and formal languages.
- Intuition: Defining the rules and structures that generate valid sequences of data.
- AI/CS Link: Essential for understanding tokenization in LLMs and the logic of string processing.
Module 2: Calculus for AI
Lecture 1 — Limits, Continuity & Derivative Foundations
- Core Concepts: Definitions of limits (0/0, ∞/∞), Sandwich Theorem. The 6 basic functions and their derivatives: xⁿ, sin, cos, eˣ (and aˣ), ln x, step/|x| functions.
- Intuition: Measuring how a function changes at an infinitesimal point.
- AI/CS Link: Limits are necessary to define derivatives used in gradient descent.
Lecture 2 — Rules of Differentiation & The Chain Rule
- Core Concepts: The 6 rules of differentiation: Sum, Product, Quotient, Inverse, Chain Rule, L’Hôpital’s Rule.
- Intuition: Calculating the rate of change for complex, nested functions.
- AI/CS Link: The Chain Rule is the mathematical engine behind backpropagation in neural networks.
Lecture 3 — Optimization: Critical Points & Curvature
- Core Concepts:
- Finding maxima, minima, and inflection points
- Second derivative test; Newton’s method
- All Values Theorem and Mean Value Theorem
- Intuition: Identifying the “peaks” and “valleys” of a function to find its best value.
- AI/CS Link: Training a model involves optimizing a loss function to find its global or local minimum.
Lecture 4 — Taylor Series & Linearization
- Core Concepts: Taylor Series expansions, first-order Taylor (linearization), and the Binomial Theorem.
- Intuition: Approximating complex non-linear functions with simpler polynomials.
- AI/CS Link: Linearization lets us understand the local geometry of a high-dimensional loss surface.
Lecture 5 — Integration & The Fundamental Theorem of Calculus
- Core Concepts: Riemann sums, Fundamental Theorem of Calculus I & II, and integral intuition.
- Intuition: Calculating the total accumulated value over an interval (area under a curve).
- AI/CS Link: Integrals define expectations in probability and are core to diffusion models.
Lecture 6 — Multivariable Calculus: Partial Derivatives & Gradients
- Core Concepts: Partial derivatives, the Gradient vector, and the Multivariable Chain Rule.
- Intuition: Understanding how a function of many variables changes as each variable is tweaked individually.
- AI/CS Link: Gradients tell us how to update every parameter in a model simultaneously.
Lecture 7 — The Jacobian & Vector-Valued Functions
- Core Concepts: Defining the Jacobian matrix and its role in multivariable transformations.
- Intuition: Extending the derivative to functions that map multiple inputs to multiple outputs.
- AI/CS Link: Crucial for understanding gradient flow through layers and activations in Deep Learning.
Lecture 8 — Convexity & High-Dimensional Optimization
- Core Concepts: Definition of convexity, the Hessian matrix, and its intuition in loss surface geometry.
- Intuition: Determining if a function is “bowl-shaped,” guaranteeing any local minimum is global.
- AI/CS Link: Convex optimization ensures stable and reliable training for many ML algorithms.
Module 3: Probability Foundations for AI
Lecture 1 — Discrete Probability & Kolmogorov Axioms
- Core Concepts: Basic probability, expectation, variance, and standard deviation. Kolmogorov axioms, sample spaces, and connecting probability to counting with several examples.
- Intuition: Quantifying uncertainty in a mathematically rigorous way.
- AI/CS Link: Provides the foundation for all probabilistic modeling and data science.
Lecture 2 — Conditional Probability & Bayes’ Theorem
- Core Concepts: Conditional probability, Law of Total Probability, Bayes’ Theorem. Application: designing spam filters.
- Intuition: Updating our beliefs about an event based on new incoming evidence.
- AI/CS Link: Used in Bayesian inference and posterior updates.
Lecture 3 — Random Variables: Expectation & Variance
- Core Concepts: Discrete and continuous random variables, PDF vs. PMF, expectation, variance, and standard deviation.
- Intuition: Summarizing a complex distribution with a single average value and a measure of spread.
- AI/CS Link: Expectation is used to calculate the average loss of a model over a dataset.
Lecture 4 — Continuous Distributions & The Gaussian
- Core Concepts: Uniform, Exponential, and Gaussian (Normal) distributions; the Multivariate Gaussian.
- Intuition: Modeling real-world data that clusters around a central mean.
- AI/CS Link: Gaussian distribution is a standard prior in VAEs and the basis for noise in diffusion models.
Lecture 5 — Covariance & High-Dimensional Geometry
- Core Concepts: Covariance and correlation matrices and their geometric interpretation.
- Intuition: Measuring how two or more variables change together.
- AI/CS Link: Covariance matrix is central to latent space modeling and feature redundancy analysis.
Lecture 6 — Limit Theorems & Sampling
- Core Concepts: Law of Large Numbers (LLN), Central Limit Theorem (CLT), and Monte Carlo sampling basics.
- Intuition: Understanding why many small, independent random factors average out into a bell curve.
- AI/CS Link: Provides intuition behind Batch Normalization and stochastic optimization (SGD).
Lecture 7 — Likelihood & Parameter Estimation
- Core Concepts: Likelihood and log-likelihood functions; derivation of Maximum Likelihood Estimation (MLE).
- Intuition: Finding the model parameters that make the observed data most likely.
- AI/CS Link: MLE is the fundamental principle used to derive loss functions like Mean Squared Error.
Lecture 8 — Information Theory: Entropy & Divergence
- Core Concepts: Entropy, Cross-Entropy, KL Divergence, Evidence Lower Bound (ELBO).
- Intuition: Measuring the information content of a distribution or the distance between two distributions.
- AI/CS Link: Cross-entropy is the standard loss for classification; KL divergence is used in VAEs and RLHF.
Module 4: Linear Algebra for AI
Lecture 1 — Vectors, Norms & Dot Products
- Core Concepts: Vector spaces, L1/L2 Norms, dot products, and cosine similarity.
- Intuition: Representing data points as positions and directions in space.
- AI/CS Link: Embeddings (word/image vectors) rely on norms and similarity for retrieval and comparison.
Lecture 2 — Matrices & Linear Transformations
- Core Concepts: Matrix-vector multiplication, linear transformations, rank, and matrix inverse.
- Intuition: Using matrices to rotate, scale, or project data into new coordinate systems.
- AI/CS Link: Each neural network layer is a linear transformation followed by a non-linearity.
Lecture 3 — Systems of Linear Equations
- Core Concepts: Row Echelon Form (REF), Gaussian elimination, and solving Ax = b.
- Intuition: Finding the intersection of multiple hyperplanes.
- AI/CS Link: Used in Linear Regression and weight updates in certain optimization methods.
Lecture 4 — Subspaces, Orthogonality & Projections
- Core Concepts: Basis, subspaces, orthogonality, and projection of a vector onto a subspace.
- Intuition: Finding the “shadow” of a high-dimensional vector in a lower-dimensional space.
- AI/CS Link: Transformer projections and dimensionality reduction rely on these geometric principles.
Lecture 5 — Eigenvalues & Eigenvectors
- Core Concepts: Characteristic equation, Eigendecomposition, and the intuition of invariant directions.
- Intuition: Finding the natural axes of a transformation where data is only scaled, not rotated.
- AI/CS Link: Central to stability of Recurrent Neural Networks (RNNs) and spectral clustering.
Lecture 6 — Singular Value Decomposition (SVD)
- Core Concepts: SVD of a matrix, singular values, and the relationship between SVD and Eigendecomposition.
- Intuition: Decomposing any matrix into three operations: rotation, scaling, and rotation.
- AI/CS Link: Used for matrix compression, denoising, and Low-Rank Adaptation (LoRA) of LLMs.
Lecture 7 — Principal Component Analysis (PCA)
- Core Concepts: Low-rank approximation using SVD and derivation of PCA from covariance.
- Intuition: Identifying directions in a dataset that contain the most variance/information.
- AI/CS Link: A primary tool for data visualization and feature reduction in Data Science.
Lecture 8 — Tensors & Multilinear Algebra
- Core Concepts: High-dimensional arrays (tensors), tensor products, and attention weights geometry.
- Intuition: Generalizing vectors (1D) and matrices (2D) to arbitrary dimensions.
- AI/CS Link: All modern Deep Learning frameworks (PyTorch/TensorFlow) operate on tensors; attention mechanisms use tensor products.
Who can join?
Graduates struggling to secure roles in software engineering or AI
Professionals seeking to integrate modern AI tools like LLMs into their workflows
BS (CS/SE/AI/Data Science) students who have completed at least 2 years of study
Whether you are beginning your journey, preparing to enter the job market, or upgrading your technical depth, it provides a clear pathway to move from fundamentals to real engineering competence in the age of AI.
About Program
Applied AI Engineering: From Probability to Generative Models & LLM Systems is a 6-month intensive, hands-on program designed to take you from core mathematical and algorithmic foundations to deploying state-of-the-art AI systems, including Generative Models, Transformers, and Large Language Models (LLMs).
Engage in mastering the essentials of linear algebra, calculus, probability, optimization, and neural networks, and then progress to building generative models (VAE, Diffusion), training transformers, and fine-tuning LLMs. Practice mathematical derivations, implement models in NumPy and PyTorch, benchmark performance, and deploy fully functional AI applications. By the end, you’ll be ready to build, optimize, and deploy AI systems, and work as an ML / Generative AI Engineer in the real world.
| Month | Focus |
|---|---|
| 1 | Mathematical Foundations (LA + Calculus compressed) |
| 2 | Probability & Density Estimation |
| 3 | Optimization & Core ML |
| 4 | Generative Models (VAE, Diffusion) |
| 5 | Deep Learning Systems & Transformers |
| 6 | Large Language Models (LLMs) & Deployment |
📘 MONTH 1 — Linear Algebra + Calculus for ML (Compressed & Focused)
Goal: Only what’s needed for ML.
Week 1 — Vectors, Geometry, Matrix Operations
Math:
- Vector spaces
- Norms
- Dot product
- Matrix multiplication
- Linear transformations
NumPy Lab:
- Implement matrix multiplication from scratch
- Build Nearest Neighbor Classifier
- Visualize 2D transformations
Torch Lab:
- GPU vs CPU tensor operations
- Batch operations & broadcasting
Mini Project:
- Implement KNN classifier fully in NumPy
Week 2 — Eigenvalues, SVD, PCA (Combined)
Math:
- Eigen decomposition
- SVD
- PCA derivation via SVD
- Low-rank approximation
NumPy Lab:
- Implement PCA manually
- Image compression via SVD
Torch Lab:
- PCA on high-dimensional dataset
- Compare reconstruction errors
Week 3 — Multivariable Calculus & Gradients
Math:
- Partial derivatives
- Gradient
- Jacobian intuition
- Chain rule
- Backprop idea
NumPy Lab:
- Compute gradients numerically
- Implement gradient descent
- Visualize 3D loss surface
Torch Lab:
- Autograd exploration
- Manual vs autograd gradient comparison
Week 4 — Optimization Theory
Math:
- Convexity
- SGD
- Momentum
- Adam
- Convergence behavior
NumPy Lab:
- Implement SGD, Momentum, Adam
- Compare convergence rates
Torch Lab:
- Custom optimizer implementation
- Learning rate scheduling
📊 MONTH 2 — Probability & Density Estimation (Core Spine)
This is the backbone of the course.
Week 5 — Probability Foundations
- Random variables
- PMF vs PDF
- Expectation
- Variance
- Covariance
- Law of Large Numbers
NumPy Lab:
- Monte Carlo simulation
- Estimate expectation via sampling
Torch Lab:
- torch.distributions exploration
Week 6 — Gaussian & Multivariate Distributions
- Multivariate Gaussian
- Covariance matrix geometry
- Likelihood function
NumPy Lab:
- Implement multivariate Gaussian PDF
- Visualize contour plots
- Compute log-likelihood
Torch Lab:
- Fit Gaussian to data via gradient descent
Week 7 — Maximum Likelihood Estimation
- MLE derivation
- Linear regression via MLE
- Logistic regression via MLE
NumPy Lab:
- Linear regression closed-form
- Logistic regression from scratch
Torch Lab:
- Build training loop
- Loss functions
- Model checkpointing
Week 8 — Latent Variables & EM
- Mixture models
- EM algorithm derivation
- GMM as density estimator
NumPy Lab:
- Implement EM from scratch
- Visualize clustering
Torch Lab:
- Log-sum-exp trick
- Stable implementation
🤖 MONTH 3 — Neural Networks & Generalization
Week 9 — Neural Networks from Scratch
- Backprop derivation
- Activation functions
- Loss functions
NumPy Lab:
- 2-layer NN with manual backprop
Torch Lab:
- Same network in nn.Module
Week 10 — Regularization & Generalization
- Bias-variance
- L1, L2
- Dropout
- BatchNorm
Lab:
- Overfitting experiment
- Regularization comparison
Week 11 — CNNs
NumPy Lab:
- Implement convolution manually
Torch Lab:
- Build CNN for CIFAR/MNIST
- Train & evaluate
Week 12 — Density Estimation with Neural Networks
- Autoregressive models
- Normalizing flows (intro)
- Energy-based models (intuition)
Torch Lab:
- Simple autoregressive density model
- Log-likelihood training
🎨 MONTH 4 — Generative AI
Week 13 — Variational Autoencoders
- ELBO derivation
- KL divergence
- Reparameterization trick
NumPy Lab:
- Derive KL divergence manually
- Visualize latent space
Torch Lab:
- Full VAE implementation
- Sample new images
Week 14 — Diffusion Models
- Forward process
- Reverse process
- Noise prediction objective
Torch Lab:
- Train simple diffusion on MNIST
- Visualize denoising process
Week 15 — Conditional Generation
- Conditional VAE
- Conditional diffusion
- Classifier-free guidance
Lab:
- Conditional image generation
Week 16 — Evaluation of Generative Models
- FID score
- Likelihood vs perceptual quality
- Mode collapse
Lab:
- Compare VAE vs diffusion outputs
🧠 MONTH 5 — Transformers & Deep Learning Systems
Week 17 — Attention Mechanism
NumPy Lab:
- Implement scaled dot-product attention from scratch
Torch Lab:
- Multi-head attention module
Week 18 — Transformer Architecture
- Encoder
- Decoder
- Positional encoding
Torch Lab:
- Build mini transformer
- Train small language model
Week 19 — Training at Scale
- Mixed precision
- Gradient clipping
- Checkpointing
- Experiment tracking
Lab:
- Train transformer with logging
- Resume from checkpoint
Week 20 — Deployment
- TorchScript
- ONNX
- FastAPI
- Docker
- Model versioning
Lab:
- Deploy transformer as REST API
- Containerize with Docker
🚀 MONTH 6 — Large Language Models (LLM Engineering)
This month makes them industry-ready.
Week 21 — LLM Internals
- Causal language modeling objective
- Tokenization (BPE, SentencePiece)
- Scaling laws
- Pretraining vs finetuning
Lab:
- Train tiny GPT from scratch (small dataset)
- Implement tokenizer
Week 22 — Fine-Tuning LLMs
- LoRA
- QLoRA
- Instruction tuning
- Prompt engineering
Lab:
- Fine-tune open LLM (e.g., Llama or Mistral)
- Build task-specific chatbot
Week 23 — RAG Systems
- Embeddings
- Vector databases
- Retrieval pipeline
- Hybrid search
Lab:
- Build RAG system with:
- Open-source LLM
- FAISS
- Document ingestion pipeline
Week 24 — LLM Deployment & Optimization
- Quantization
- vLLM
- Inference optimization
- API deployment
- Safety & alignment basics
Final Lab:
- Deploy production-ready LLM API
- Implement:
- Rate limiting
- Logging
- Monitoring
🎓 CAPSTONE PROJECT OPTIONS
Students must deliver:
- Research report (math + theory)
- GitHub repo (clean structure)
- Dockerized deployment
- Technical presentation
Possible Tracks:
- Custom diffusion model
- End-to-end RAG system
- Fine-tuned domain LLM
- Density estimation research project
- Vision-language model
🧪 LAB STRUCTURE TEMPLATE (Standardized)
Every lab includes:
- Mathematical derivation section
- NumPy implementation
- Torch production implementation
- Benchmarking
- Debugging exercises
- Reflection questions
📊 Evaluation Scheme
| Component | Weight |
|---|---|
| Weekly Labs | 30% |
| Midterm (Math + Coding) | 20% |
| Mini Project (Month 3) | 15% |
| Generative Model Project | 15% |
| Final Capstone | 20% |
🛠 Tool Stack
- Python
- NumPy
- PyTorch
- HuggingFace
- FAISS
- FastAPI
- Docker
- Weights & Biases
- Git
🎯 Final Graduate Profile
After 6 months, students can:
- Derive MLE & ELBO
- Implement backprop manually
- Train diffusion models
- Understand transformer math
- Fine-tune LLMs
- Build RAG systems
- Deploy AI systems
- Debug training instability
- Work as ML / GenAI Engineer
Who can join?
- Graduates preparing for technical interviews for engineering roles at their dream organization
- BS (CS/SE/AI/Data Science) students who have completed at least 2 years of study and want to
- get an unfair advantage in programming competitions
- secure internships at the best companies
- secure summer program scholarships at prestigious foreign universities
- Mid-career engineers looking to level up their career
Acing the coding interview at the organization of your dreams requires a specific training routine. This course takes you through the steps to develop the foundational skills, provides the regular routine of solving a wide variety of problems to develop a creative problem-solving mindset, and equips you with the skills and confidence to effectively analyse new problems and design efficient solutions.
About The Course
Cracking the Coding Interview is a comprehensive, interview-focused course which guides students through core computer science fundamentals including data understanding, algorithm efficiency, and effective problem-solving strategies.The course covers essential topics such as arrays, strings, stacks, queues, STL, recursion, dynamic programming, graphs, greedy algorithms, priority queues, and dynamic data structures like linked lists, hash tables, and binary trees. Learners practice with 150+ LeetCode problems, gaining hands-on experience in solution space exploration and optimization. In addition, the course strengthens interview readiness through object-oriented programming, databases, operating systems (threads and locks), theory of computation, and quantitative and analytical problem solving equipping participants with both the technical depth and confidence required to succeed in real-world technical interviews.
📘 Course Outline
📅 Month 1: Programming Fundamentals
Week 1: Loops, Functions & Basics
- Lecture 1: Environment Setup, Data Types, Conditionals, Loops
- Lecture 2: Functions, Recursion, Time Complexity
- Lab: Shapes Printer, Console Animation
Week 2: Arrays & Sorting
- Lecture 1: Arrays, Strings, 2D Arrays, Searching
- Lecture 2: Sorting Algorithms, Merge & Quick Sort
- Lab: Voting System, Snakes & Ladders
Week 3: Pointers & Memory
- Lecture 1: Pointers, Stack vs Heap, Dynamic Memory
- Lecture 2: Function Pointers, Const & Smart Pointers
- Lab: Gomoku Game
Week 4: Structs & Chess Project
- Lecture 1: Structs, Enums, Data Modeling
- Lecture 2: File Handling, Function Pointer Dispatch
- Lab: Chess Game (Procedural)
📅 Month 2: OOP & Design Patterns
Week 5: Classes & OOP Basics
- Class Structure, Constructors, Destructors
- Lab: Polynomial Calculator
Week 6: Operator Overloading
- Arithmetic & Advanced Overloading
- Lab: Huge Integer Project
Week 7: Relationships & STL
- Object Relationships, Design Patterns
- Lab: LUDO Game
Week 8: Inheritance & Polymorphism
- OOP Concepts, Behavioural Patterns
- Lab: Chess (OOP Version)
📅 Month 3: Data Structures & STL
Week 9: Stack, Queue, Vector
- Implementation and STL mapping of basic data structures
Week 10: Linked Lists
- Singly, Doubly, and Circular Linked Lists with applications
Week 11: Trees
- Binary Trees, BST, AVL, Heaps, and Tries
Week 12: Hashing
- Hash tables, collision handling, real-world use cases
📅 Month 4: Algorithms
Week 13: Divide & Conquer
- Recurrence relations and divide & conquer strategies
Week 14: Dynamic Programming
- Optimization using DP (1D, 2D, advanced patterns)
Week 15: Greedy Algorithms
- Greedy strategies and optimization problems
Week 16: Graph Algorithms
- BFS, DFS, shortest paths, graph problems
📅 Month 5: Operating Systems, Databases & System Design
Week 17: Operating Systems
- Processes, scheduling, threads, synchronization
Week 18: Memory & File Systems
- Memory management and file handling systems
Week 19: Databases (SQL)
- SQL, indexing, transactions, database design
Week 20: System Design
- Scalable systems, architecture, design patterns
📅 Month 6: Mock Interviews
Week 21: DSA Mock Interviews
- Practice real interview-style coding problems
Week 22: System Design Interviews
- Mock interviews focused on system design
Week 23: Behavioural Preparation
- Communication skills, HR questions, STAR method
Week 24: Final Mock & Launch
- Full interview simulation and final preparation







