What Junior ML Engineers Get Wrong About Talking to Interviewers

Q: Why did you use gradient boosting?

A: So, decision trees split data on features, and a single
tree can overfit. Random forests average many trees, that's
bagging. Boosting is different because each tree corrects
the errors of the previous one, using gradients of the loss.
There's a learning rate and number of estimators... and so
for my data it gave the best result compared to the others.

(The real answer arrived in the last eight words.)

Q: Why did you use gradient boosting?

A: Because it clearly beat my logistic regression baseline
on recall, and my data had non-linear interactions, like
income mattering differently by age group.

The trade-off was explainability, so I added SHAP plots for
the top features.

I can go into how I tuned it if that's useful.

TO AN ML LEAD
"I tuned the threshold for recall at a fixed precision,
because each flagged case costs a manual review and the team
can handle a limited number per day."

TO A PRODUCT MANAGER
"Of the cases we flag, most are real problems, and we
catch most of the real problems. I set it so the review team
is not flooded with false alarms."

TO HR
"I worked with the review team to understand how many cases
they could handle, and tuned the model to fit that."

TO AN ML LEAD
"The unconstrained tree had a large train-validation gap.
I limited max_depth and min_samples_leaf and used
cross-validation to choose them."

TO A PRODUCT MANAGER
"The first version memorised past cases and did worse on new
ones. I made it simpler so it works reliably on new data."

TO HR
"My first attempt looked great on old data but failed on new
data. I learned to always test on data the model had not seen."

def precision_recall(y_true, y_pred):
    # Plan: one pass to count TP, FP, FN, then divide.
    tp = fp = fn = 0
    for t, p in zip(y_true, y_pred):
        if p == 1 and t == 1:
            tp += 1
        elif p == 1 and t == 0:
            fp += 1
        elif p == 0 and t == 1:
            fn += 1
    # Edge case: no predicted positives or no actual positives
    precision = tp / (tp + fp) if (tp + fp) else 0.0
    recall = tp / (tp + fn) if (tp + fn) else 0.0
    return precision, recall


# Quick test I say out loud: 2 TP, 1 FP, 1 FN
y_true = [1, 1, 0, 1, 0]
y_pred = [1, 1, 1, 0, 0]
print(precision_recall(y_true, y_pred))  # (0.666..., 0.666...)
print(precision_recall([0, 0], [0, 0]))   # (0.0, 0.0)

"I'll go through both lists together with zip and count
three things: true positives, false positives and false
negatives. True negatives aren't needed for these two metrics.

Now the division. If the model predicts no positives,
tp plus fp is zero, so I'll return 0.0 instead of crashing.
Same for recall.

Let me test with a small case I can check by hand: two true
positives, one false positive, one false negative, so both
should be two-thirds. Yes. And the all-zero case returns 0.0."

HEADLINE DRILL (10 minutes)

1. Write 10 'why' questions about your own projects.
   e.g. Why this model? Why this metric? Why this split?
2. For each, write a ONE-sentence answer. No 'so', no
   background. Just the conclusion and one reason.
3. Say each aloud. Then add at most two supporting sentences.
4. End each with an offer: 'I can go deeper on ___.'

Check: does your first sentence answer the question alone?

THREE-DEPTH DRILL (15 minutes)

Pick one concept a day:
  overfitting, precision vs recall, cross-validation,
  feature importance, data drift, embeddings

Explain it three times, about 30 seconds each:
  [ ] to an ML lead (precise terms, trade-offs)
  [ ] to a product manager (impact and risk)
  [ ] to a friend outside tech (plain words, one example)

If the plain version is wrong or vague, you do not
fully understand the concept yet.

NARRATION DRILL (15 minutes)

Solve a small ML coding task out loud, recording audio:
  - accuracy / precision / recall from scratch
  - train/validation split without sklearn
  - min-max scaling of a list
  - confusion matrix as a dictionary

After recording, check:
  [ ] I stated a plan before typing
  [ ] I explained at least one edge case
  [ ] No silence longer than about 20 seconds
  [ ] I tested with a hand-checkable example