Interview Readiness and Capstone Launch

An ML/AI engineering interview at a product company has four components: coding, ML theory, system design, and behavioral. Each rewards different preparation strategies. This module provides a framework for each, and guidance on structuring your capstone project as the centerpiece of your interview narrative.

The Five Interview Formats

1. ML Coding (45–60 min)

You will be asked to implement something: gradient descent from scratch, a cross-validation loop, a data cleaning pipeline, a simple neural network in NumPy, or a feature engineering function.

Practice targets:

• Implement k-fold cross-validation without sklearn
• Implement batch gradient descent on a linear regression loss
• Write a pipeline that handles missing values, encodes categoricals, and scales numerics
• Implement cosine similarity and find the top-k most similar vectors in a matrix

pythonCopy
# Common interview pattern: implement metric from scratch
def precision_recall_f1(y_true, y_pred):
    tp = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 1)
    fp = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 1)
    fn = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 0)
    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
    return precision, recall, f1

2. ML Theory (30–45 min)

Expect questions like:

• "Explain the bias-variance tradeoff and how it affects your model selection decisions."
• "Why does L1 regularization produce sparse solutions but L2 doesn't?"
• "What is the difference between bagging and boosting?"
• "Why is logistic regression output well-calibrated when gradient boosting is not?"
• "Explain how backpropagation works at the level of the chain rule."

Preparation strategy: be able to answer each question in 2–3 minutes with an intuition-first explanation, a brief mathematical statement, and a practical implication. Avoid starting with equations - start with the mental model.

3. System Design (45–60 min)

This is covered in Module 28 in depth. For interview prep specifically:

• Practice the 5-minute structured answer format: requirements → architecture → components → tradeoffs → failure modes.
• Have 2–3 systems you have designed or studied deeply, including the tradeoffs you considered.
• Practice talking about systems you have built: "In my capstone project, I designed a RAG system where I chose FAISS over pgvector because..."

4. Behavioral (30 min)

Use the STAR format (Situation, Task, Action, Result) for every behavioral answer. Prepare 5–8 stories that each cover multiple common questions:

Story Type	Questions it answers
Designed a system from scratch	"Tell me about a technical challenge you solved"
Disagreed with a technical decision	"Tell me about a time you pushed back"
Debugging a production failure	"Tell me about a time something went wrong"
Improved a team process	"Tell me about a time you made the team more effective"
Learned a new technology under pressure	"Tell me about a time you had to grow quickly"

5. Agents and Evals (30–45 min)

A newer round that appears in most AI engineering loops. Expect a scenario like "an agent that triages incoming bug reports" and questions in this order: what tools does it get and what can it not do; how is each tool call validated, executed, and logged; how do you evaluate it (final answer, trajectory, production signals) and keep it from regressing; and how do you decide which requests deserve a reasoning model. The strongest evidence you can bring is a project where you built the harness and the eval suite yourself: an MCP server with a few tools, a permission model with an approval state for side effects, a 30-task eval with trajectory grading, and one red-team finding you fixed. Practice explaining the whole thing in five minutes with one diagram.

The Capstone as Interview Evidence

Your capstone should be the centerpiece of both your portfolio and your interview answers. Structure it so every interview format has something to draw on:

Coding: the capstone includes a data pipeline, feature engineering module, and evaluation harness - all runnable and testable.

Theory: you made model selection decisions (why LightGBM over logistic regression, why LoRA over full fine-tuning) that you can explain from first principles.

System design: the capstone is a full system with a defined architecture. You can draw it on a whiteboard and walk through the tradeoffs.

Behavioral: the capstone involved debugging, making decisions under uncertainty, and dealing with problems you did not anticipate - all material for behavioral answers.

A Minimal Capstone Scope

A capstone that covers the full breadth does not need to be complex. A well-executed minimal scope beats an ambitious scope that is incomplete.

Recommended minimal scope:

1. A real dataset (not Kaggle leaderboard). Public datasets with genuine messiness are fine.
2. A data pipeline that takes raw data to a clean, versioned feature set.
3. A model with hyperparameter tuning and a proper held-out test evaluation.
4. A serving component (even a FastAPI endpoint running locally is sufficient).
5. An evaluation report documenting: data decisions, model decisions, results, limitations.

Optional additions (if your target role benefits):

• RAG component for LLM-powered features
• A monitoring plan (even a document describing what you would monitor)
• A CI workflow that runs tests and validates the pipeline

Preparing for Rejection and Iteration

Most candidates need multiple interview cycles to land a role. Plan for this:

• Keep notes on every question you were asked and which answers landed well.
• After each interview, add the questions you struggled with to your study list.
• A second or third interview cycle after additional preparation is the norm, not a failure.

Target companies: apply to 15–20 ML/AI engineering roles, across a range of company sizes and stages. Junior candidates often underestimate non-FAANG roles that offer more autonomy, faster growth, and genuine ML ownership.

Where to Go Next

You have completed the college path curriculum. The next phase is:

1. Build your capstone using the architecture from your Module 28 system design.
2. Document it using the portfolio framework from Module 29.
3. Apply and use the interview prep framework from this module.

The skills you have built are exactly what strong product-company ML teams are looking for. The gap between skill and hire is almost always in the portfolio and interview execution - both of which are fully improvable with deliberate practice.