Atlassian & Intuit: Machine Learning Engineer

• Contexts: the home feed ("for you"), "related pages" on a page, and search-adjacent suggestions.
• Signals: the user's space and team membership, recently viewed or edited pages, Jira issues they work on, collaborators, page popularity and freshness, permissions (never recommend pages the user can't see).
• Candidates: co-view graph (item-to-item), content embeddings (title + body), pages from the user's team and spaces, trending pages.
• Ranker: GBM or a two-tower model predicting P(click) and P(dwell longer than 30 s); diversity and freshness re-ranking.
• Cold start: new users get team and space popular pages; new pages get content similarity plus exploration.
• Evaluation: offline recall@k / NDCG on held-out views; online CTR, dwell time and return visits; guardrails on latency and permission leaks (zero tolerance).

import heapq
class StockPrice:
    def __init__(self):
        self.p, self.latest = {}, 0
        self.maxh, self.minh = [], []
    def update(self, t, price):
        self.p[t] = price; self.latest = max(self.latest, t)
        heapq.heappush(self.maxh, (-price, t)); heapq.heappush(self.minh, (price, t))
    def current(self): return self.p[self.latest]
    def maximum(self):
        while -self.maxh[0][0] != self.p[self.maxh[0][1]]: heapq.heappop(self.maxh)   # lazy delete stale
        return -self.maxh[0][0]
    def minimum(self):
        while self.minh[0][0] != self.p[self.minh[0][1]]: heapq.heappop(self.minh)
        return self.minh[0][0]

• Two heaps with lazy deletion: O(log n) amortised. Add unit tests for corrections at the same timestamp.

from dataclasses import dataclass
OPEN, CLOSE = 10 * 60, 23 * 60
@dataclass(frozen=True)
class Show: start: int; duration: int          # minutes since midnight
def can_schedule(shows: list[Show], duration: int) -> int | None:
    """Return the earliest start minute that fits, or None."""
    slots = sorted(shows, key=lambda s: s.start); t = OPEN
    for s in slots:
        if s.start - t >= duration: return t
        t = max(t, s.start + s.duration)
    return t if CLOSE - t >= duration else None

assert can_schedule([Show(600, 120), Show(780, 90)], 60) == 720
assert can_schedule([Show(600, 780)], 30) is None

• Discuss: validation (overlapping existing shows), multiple screens (a list per screen), time zones, extensibility (a pluggable rule set), and tests for boundary cases (exactly fits at 23:00).

Answer (a structure that works):

• Challenge 1 (data): "Labels were noisy. 15% disagreement found by an audit." Action: relabelling guidelines plus confident learning to flag likely errors. Result: +4 F1.
• Challenge 2 (serving): "p95 latency was 400 ms." Action: distilled the model and cached embeddings. Result: 80 ms.
• Keep each one to challenge → decision → measurable result, and be ready for "why not X?" follow-ups.

• Inputs: merchant name and description text, amount, MCC code, date, the user's past categorisations, the business type.
• Model: text embeddings + tabular features → a classifier; personalisation from user corrections (a per-user override memory or fine-tuning).
• Cold start: global model priors by merchant; active learning that asks users about low-confidence items.
• Metrics: accuracy and macro-F1 by category, correction rate, time saved.
• Trust: explanations ("categorised as Travel because of the merchant 'IndiGo'"), easy undo, privacy controls.