Your 90-Day Study Plan

Why 90 Days?

Research shows that 90 days (12-13 weeks) is the optimal preparation period for ML engineering interviews:

Too short (<60 days): Rushed preparation, gaps in knowledge
Just right (90 days): Sufficient time to build deep understanding and practice
Too long (>120 days): Burnout risk, knowledge decay, motivation loss

Your Baseline Assessment

Before starting, honestly assess your current level:

Python & Algorithms

Can solve LeetCode Easy problems in <15 minutes
Understand time/space complexity analysis
Comfortable with data structures (arrays, trees, graphs)
Can implement algorithms from scratch

ML Fundamentals

Understand supervised vs unsupervised learning
Can explain common algorithms (linear regression, decision trees, neural networks)
Know evaluation metrics (accuracy, precision, recall, F1)
Familiar with overfitting and regularization

Production ML

Have deployed at least one ML model
Understand model serving (batch vs real-time)
Familiar with A/B testing
Know basic MLOps concepts

Count your checkmarks:

0-4: Beginner (focus on fundamentals)
5-8: Intermediate (balanced preparation)
9-12: Advanced (focus on system design and depth)

The 90-Day Framework

Month 1: Build Your Foundation (Weeks 1-4)

Week 1: Python & Data Structures Time commitment: 10-12 hours

Daily Focus (2 hours/day):

Day 1-2: Arrays and strings (5 LeetCode Easy problems)
Day 3-4: Hash tables and sets (5 LeetCode Easy problems)
Day 5-6: Stacks and queues (5 LeetCode Easy problems)
Day 7: Review and practice (10 mixed Easy problems)

Key Resources:

LeetCode: Explore > Arrays, Hash Table, Stack/Queue
Python Docs: List comprehensions, dictionaries, collections module
YouTube: NeetCode "Blind 75" series

Success Metric: Solve 30 Easy problems with 80%+ accuracy

Week 2: Algorithms Fundamentals Time commitment: 12-15 hours

Daily Focus (2-3 hours/day):

Day 1-2: Sorting algorithms (implement quicksort, mergesort from scratch)
Day 3-4: Binary search variations (5 problems)
Day 5-6: Two pointers and sliding window (5 problems)
Day 7: Recursion basics (5 problems)

Practice Problems:

# Example: Binary search implementation
def binary_search(arr, target):
    """
    Practice: Implement binary search
    Then try: Search in rotated array, find peak element
    """
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

Success Metric: Solve 25 Easy/Medium problems, understand O(n log n) complexity

Week 3: ML Fundamentals - Supervised Learning Time commitment: 15-18 hours

Daily Focus (3 hours/day):

Day 1: Linear regression (theory + implementation from scratch)
Day 2: Logistic regression (theory + implementation)
Day 3: Decision trees (CART algorithm, splitting criteria)
Day 4: Random forests (bagging, feature importance)
Day 5: Gradient boosting (XGBoost, LightGBM)
Day 6: SVMs (kernel trick, margin optimization)
Day 7: Practice interview questions on all algorithms

Hands-On Project: Build a classification model from scratch:

# Implement gradient descent for logistic regression
class LogisticRegression:
    def __init__(self, lr=0.01, epochs=1000):
        self.lr = lr
        self.epochs = epochs
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        """Implement training logic"""
        # Your implementation
        pass

    def predict(self, X):
        """Implement prediction logic"""
        # Your implementation
        pass

Success Metric: Implement 3 algorithms from scratch, explain trade-offs

Week 4: ML Fundamentals - Unsupervised Learning & Neural Networks Time commitment: 15-18 hours

Daily Focus (3 hours/day):

Day 1: K-Means clustering (implementation, elbow method)
Day 2: Dimensionality reduction (PCA, t-SNE)
Day 3: Neural networks basics (forward prop, backprop)
Day 4: Activation functions and loss functions
Day 5: Optimization (SGD, Adam, learning rate scheduling)
Day 6: Regularization (L1/L2, dropout, batch normalization)
Day 7: Mini-project: Build a simple neural network from scratch

Interview Questions to Practice:

"Explain backpropagation like I'm a software engineer"
"When would you use ReLU vs sigmoid?"
"How do you prevent overfitting?"
"What's the vanishing gradient problem?"

Success Metric: Implement a 2-layer neural network from scratch

Month 2: Deepen Skills & Practice (Weeks 5-8)

Week 5: Advanced Algorithms Time commitment: 15-18 hours

Daily Focus (3 hours/day):

Day 1-2: Tree problems (DFS, BFS, 10 problems)
Day 3-4: Dynamic programming (5 classic problems: fibonacci, knapsack, LCS)
Day 5-6: Graph algorithms (Dijkstra, topological sort, 5 problems)
Day 7: Mock coding interview (45 minutes, record yourself)

Focus on ML-Flavored Problems:

Matrix manipulation (NumPy-style)
String parsing (data preprocessing)
Graph traversal (recommendation systems)

Success Metric: Solve 30 Medium problems, 2 Hard problems

Week 6: Model Evaluation & Debugging Time commitment: 12-15 hours

Daily Focus (2-3 hours/day):

Day 1: Classification metrics (precision, recall, F1, ROC-AUC)
Day 2: Regression metrics (MSE, MAE, R²)
Day 3: Cross-validation strategies (k-fold, stratified, time-series)
Day 4: Bias-variance tradeoff (visual intuition)
Day 5: Debugging scenarios (overfitting, underfitting, data leakage)
Day 6: Feature engineering and selection
Day 7: Practice debugging interview questions

Debugging Scenarios to Master:

Symptom	Likely Cause	Solution
High train, low test accuracy	Overfitting	Regularization, more data, simpler model
Low train, low test accuracy	Underfitting	More features, complex model, less regularization
Loss not decreasing	Learning rate, bad initialization	Tune LR, check gradients, normalize data
Train loss sudden spike	Exploding gradients, bad batch	Gradient clipping, check data, lower LR

Success Metric: Diagnose and solve 20 debugging scenarios

Week 7: Deep Learning Time commitment: 15-18 hours

Daily Focus (3 hours/day):

Day 1: CNNs (convolution, pooling, architectures)
Day 2: RNNs and LSTMs (sequence modeling)
Day 3: Transformers (attention mechanism, BERT, GPT)
Day 4: Transfer learning and fine-tuning
Day 5: Training large models (distributed training, mixed precision)
Day 6: Common architectures (ResNet, VGG, BERT, T5)
Day 7: Interview questions on deep learning

Interview Questions to Practice:

"Explain the attention mechanism"
"Why do transformers work better than RNNs for NLP?"
"How would you fine-tune BERT for your use case?"
"What's the difference between BERT and GPT?"

Success Metric: Explain 5 architectures and their trade-offs

Week 8: Applied ML & Case Studies Time commitment: 18-20 hours

Daily Focus (3-4 hours/day):

Day 1: Recommendation systems (collaborative filtering, content-based)
Day 2: NLP applications (sentiment analysis, named entity recognition)
Day 3: Computer vision (object detection, image classification)
Day 4: Time series forecasting (ARIMA, Prophet, LSTMs)
Day 5: Anomaly detection (isolation forest, autoencoders)
Day 6: Ranking and search (learning to rank, BM25)
Day 7: Take-home project simulation (4-hour project)

Case Study Practice: "Build a spam detection system"

Data: Email text, metadata (sender, time, attachments)
Features: TF-IDF, sender reputation, link count
Model: Start with logistic regression, try naive Bayes
Evaluation: Precision (minimize false positives), recall (catch spam)
Deployment: Real-time inference, model updates

Success Metric: Complete 5 end-to-end case studies

Month 3: System Design & Mock Interviews (Weeks 9-12)

Week 9: ML System Design Fundamentals Time commitment: 15-18 hours

Daily Focus (3 hours/day):

Day 1: Data pipelines (ingestion, storage, preprocessing)
Day 2: Feature stores (offline vs online features)
Day 3: Model serving (batch vs real-time, latency requirements)
Day 4: Monitoring and alerting (drift detection, performance metrics)
Day 5: A/B testing and experimentation
Day 6: Model retraining strategies
Day 7: End-to-end system design practice

Template for System Design:

1. Requirements (5 min)
   - Scale (users, requests, data size)
   - Latency (real-time vs batch)
   - Accuracy requirements

2. Data Pipeline (10 min)
   - Data sources
   - Storage (data lake, data warehouse)
   - Preprocessing

3. Model (15 min)
   - Algorithm choice
   - Training pipeline
   - Feature engineering

4. Serving (10 min)
   - Inference architecture
   - Caching strategy
   - Fallback mechanisms

5. Monitoring & Iteration (10 min)
   - Metrics to track
   - Alerting rules
   - Retraining triggers

6. Trade-offs (10 min)
   - Discuss alternatives
   - Cost vs performance
   - Complexity vs maintainability

Success Metric: Design 3 complete ML systems

Week 10: Company-Specific Preparation Time commitment: 12-15 hours

Daily Focus (2-3 hours/day):

Day 1-2: Research target companies (read engineering blogs)
Day 3-4: Review Glassdoor interview experiences
Day 5: Practice company-specific questions
Day 6: Prepare behavioral stories using STAR method
Day 7: Questions to ask interviewers

STAR Stories to Prepare:

Technical challenge: "Tell me about a difficult ML problem you solved"
Failure: "Describe a model that failed in production"
Collaboration: "Tell me about working with cross-functional teams"
Ambiguity: "Describe a project with unclear requirements"
Impact: "What's your most impactful ML work?"
Disagreement: "Tell me about a time you disagreed with a technical decision"
Learning: "Describe a new technology you learned quickly"

Success Metric: 7 polished STAR stories, 10 questions for interviewers

Week 11: Mock Interviews Time commitment: 10-15 hours

Schedule:

Monday: Coding interview (45 min with peer or Pramp)
Tuesday: Review and improve
Wednesday: ML fundamentals interview (60 min)
Thursday: Review and improve
Friday: System design interview (60 min)
Saturday: Behavioral interview (30 min)
Sunday: Review all feedback, identify weak areas

Mock Interview Platforms:

Pramp (free peer interviews)
Interviewing.io (paid, with FAANG engineers)
LeetCode Mock Interviews
Friends or colleagues

Success Metric: Complete 4 full mock interviews, address all feedback

Week 12: Final Review & Polishing Time commitment: 15-20 hours

Daily Focus (3-4 hours/day):

Day 1: Review algorithm weak spots (redo failed problems)
Day 2: Review ML concept weak spots
Day 3: System design practice (2 complete designs)
Day 4: Behavioral practice (record yourself)
Day 5: Company research and final questions
Day 6: Light review, confidence building
Day 7: Rest and mental preparation

Pre-Interview Checklist:

Tested video/audio setup
Prepared questions for each interviewer
Reviewed your resume projects deeply
Printed or opened study notes for quick reference
Set up quiet, professional interview space
Prepared pen, paper, water for virtual interviews
Reviewed company values and recent news
Practiced explaining your background in 2 minutes

Success Metric: Feel confident, rested, and ready

Weekly Time Commitment

Week	Focus Area	Hours	Intensity
1	Python & Data Structures	10-12	Light
2	Algorithms	12-15	Medium
3	ML Supervised	15-18	Heavy
4	ML Unsupervised & NNs	15-18	Heavy
5	Advanced Algorithms	15-18	Heavy
6	Evaluation & Debugging	12-15	Medium
7	Deep Learning	15-18	Heavy
8	Applied ML	18-20	Very Heavy
9	System Design	15-18	Heavy
10	Company Prep	12-15	Medium
11	Mock Interviews	10-15	Heavy
12	Final Review	15-20	Medium

Average: 14-16 hours per week

Customizing for Your Situation

If you have less time (6-8 hours/week):

Extend to 120 days (16-17 weeks)
Skip some advanced topics
Focus on fundamentals and coding
Prioritize quality over quantity

If you have more time (20-25 hours/week):

Compress to 60 days (8-9 weeks)
Add more mock interviews
Deep dive into research papers
Build additional projects

If targeting specific company tier:

FAANG+: +20% time on algorithms, +30% on system design
Startups: +40% time on projects, -30% on LeetCode
Research Labs: +50% time on ML theory, read papers daily

Progress Tracking

Use a spreadsheet to track:

LeetCode problems solved (Easy/Medium/Hard)
ML concepts mastered (self-assessment 1-5)
Mock interview scores
Weekly hours committed
Energy and motivation levels

Red Flags to Watch:

Not hitting weekly hour targets
LeetCode acceptance rate <60%
Skipping mock interviews
Burnout symptoms (exhaustion, dread)

Adjustments:

If falling behind: Focus on fewer topics deeply
If burning out: Take 2-3 day break, reduce hours
If progressing well: Add harder problems, more mocks

Key Takeaways

Consistency beats intensity: 2 hours daily is better than 14 hours on Sunday
Active learning: Implement from scratch, don't just watch videos
Mock interviews are critical: They're the closest thing to real interviews
Track everything: Data helps you adjust strategy
Rest matters: Sleep, exercise, and breaks prevent burnout

What's Next?

In Module 2, we'll dive deep into Python coding and algorithm patterns specifically designed for ML engineering interviews.

:::

Quiz