Lyft Machine Learning Engineer Interview Preparation Guide - Entry Level

Direct answer

An API is a set of rules that lets two pieces of software ask each other for things and get a response back, the same way a restaurant menu lets you ask the kitchen for a specific dish without needing to know how it's cooked. For support, the practical version is: our product and some other company's system talk to each other automatically over the internet, in a fixed, agreed format, and when that conversation fails, it looks like "the app is broken" even though our code and their code may both be working correctly on their own.

Walking through the request/response flow, and what to leave out

• Client asks, server answers. Frame every API call as one system asking a narrow question ("what is this customer's order status?") and the other giving a narrow answer. Don't teach REST verbs or endpoint names to a support audience, they need the shape of the interaction, not the vocabulary.
• Name the four things that can go wrong, because that's what a support rep actually needs on the spot: the question was asked wrong (a bug on our side), the other system refused to answer (their outage, or our access was revoked), the answer came back garbled or incomplete (a partial failure), or the answer took too long and we gave up waiting (a timeout). Mapping a customer's symptom to one of these four buckets is the real skill being taught here, not the word "API" itself.
• Decide what to omit on purpose: authentication and rate limits are real and matter to engineers, but for a support rep they collapse into one sentence, sometimes the connection itself needs permission or is being used too much, and that shows up looking like the same kind of failure as an outage. Don't walk through how tokens work, it adds vocabulary without adding troubleshooting power.
• Check understanding with a real ticket, not a definition. Hand them a recent "the button doesn't do anything" ticket and ask which of the four failure buckets it fits.

Worked example

Say a customer reports our order-status page came back empty. Behind the scenes, when they loaded that page, our app sent a request to our shipping partner's system asking, in effect, "what's the status of order 48213?" Two things can happen: the shipping partner answers with the status and our page displays it, or something breaks in that exchange, their system is down, our request had a typo, or the token proving we're allowed to ask has expired, and our page has nothing to show, so it renders blank instead of an error message. For the support rep, the API is the reason "our website" and "the shipping company's website" can disagree at the exact same moment: they're two separate systems, and this blank page is what it looks like when the conversation between them fails partway through, not when either system is fundamentally broken.

Trade-offs and pitfalls

The waiter analogy earns its keep for the request/response shape, but it breaks down the moment a rep asks "so can I just call them and ask directly?", real APIs are automated, high-volume, and machine-to-machine, there's no waiter to flag down. Say that limit out loud rather than let them assume a human process exists behind it. The bigger pitfall is oversimplifying past the point of being useful: a support rep who can only say "it's an API problem" can't triage a ticket. The four-bucket failure model above is close to the minimum depth that turns the definition into something actionable, cut much further and the explanation stays clear but becomes useless.

The idea

A subsequence keeps elements in their original order but may skip any of them (unlike a substring, it need not be contiguous). The task is the length of the longest subsequence whose values are strictly increasing, meaning each value is larger than the previous one, so equal neighbours are not allowed. The insight is to anchor on where a subsequence ends: the best one ending at position i is one more than the best one ending at some earlier position j with a smaller value.

Brute force first

In the recursion below the starting "previous value" is float("-inf"), negative infinity: a number smaller than every real value, so the first element always passes the test a[i] > prev.

The recursion go(i, prev) decides each element in turn, skip it or (if it exceeds the last value taken) take it. It counts its own calls with the root included: on the increasing arrays 0..n-1 it makes 1, 3, 7, 15, 31, 63 calls for n = 0 to 5, which is 2^(n+1) - 1, so it doubles with every element. On the example array it makes 108 calls. Memoizing (caching each (position, last-taken index) pair) lowers that to 62 calls but still has up to about n^2 / 2 states: a state is a pair (position i, index of the last value taken), and the last-taken index must be an earlier position, so position i has at most i + 1 choices (counting "nothing taken yet"), and 1 + 2 + ... + n is about n^2 / 2. Redefining the state as "ends at index i" gives only n states.

The five decisions of the DP

1. What one cell means: dp[i] is the length of the longest strictly increasing subsequence that ends exactly at index i, so it must include a[i].
2. Transition: dp[i] = 1 + max(dp[j]) over all j < i with a[j] < a[i]. It is correct because any increasing subsequence ending at i is some subsequence ending at an earlier j with a smaller value, followed by a[i]; the best choice of j gives the best length.
3. Base case: dp[i] = 1 when no earlier value is smaller (the element on its own).
4. Fill order: i from left to right, because dp[i] reads only smaller indices.
5. Where the answer is read: max(dp), not dp[n-1], because the best subsequence can end anywhere. For an empty array the answer is 0.

import random
from functools import lru_cache
from itertools import combinations

def brute(a, strict=True):
    """Try every subsequence (tiny inputs only)."""
    best = 0
    for k in range(len(a) + 1):
        for sub in combinations(a, k):
            if all(x < y if strict else x <= y for x, y in zip(sub, sub[1:])):
                best = max(best, k)
    return best

def recursive(a):
    """go(i, prev): longest increasing subsequence in a[i:] whose values all exceed prev. Counts calls."""
    calls = 0
    def go(i, prev):
        nonlocal calls
        calls += 1
        if i == len(a):
            return 0
        best = go(i + 1, prev)                           # skip a[i]
        if a[i] > prev:
            best = max(best, 1 + go(i + 1, a[i]))        # take a[i]
        return best
    return go(0, float("-inf")), calls

def memoized(a):
    @lru_cache(maxsize=None)
    def go(i, prev_index):
        if i == len(a):
            return 0
        best = go(i + 1, prev_index)
        if prev_index < 0 or a[i] > a[prev_index]:
            best = max(best, 1 + go(i + 1, i))
        return best
    result = go(0, -1)
    info = go.cache_info()
    return result, info.hits + info.misses

def lis_quadratic(a, strict=True, trace=False):
    """dp[i] = length of the longest increasing subsequence that ENDS at index i."""
    n = len(a)
    dp = [1] * n                                         # base case: a[i] alone
    comparisons = 0
    for i in range(n):
        for j in range(i):
            comparisons += 1
            if (a[j] < a[i]) if strict else (a[j] <= a[i]):
                dp[i] = max(dp[i], dp[j] + 1)
        if trace:
            print("  i =", i, " a[i] =", a[i], " smaller earlier values at j =",
                  [j for j in range(i) if a[j] < a[i]], " dp[i] =", dp[i])
    return (max(dp) if n else 0), dp, comparisons

tiny = [3, 1, 2, 4]
print("tiny array:", tiny)
tiny_best, tiny_dp, tiny_comparisons = lis_quadratic(tiny, trace=True)
print("dp:", tiny_dp, " answer:", tiny_best, " comparisons:", tiny_comparisons)

arr = [10, 9, 2, 5, 3, 7, 101, 18]
print("array:", arr)
best, dp, comparisons = lis_quadratic(arr, trace=True)
print("dp:", dp, " answer = max(dp):", best, " inner-loop comparisons:", comparisons, " n(n-1)/2 =", len(arr) * (len(arr) - 1) // 2)
print("brute force:", brute(arr), " recursion (value, calls):", recursive(arr), " memoized (value, calls):", memoized(arr))

print("recursion calls on 1..n (root counted), n = 0..5:", [recursive(list(range(n)))[1] for n in range(6)])
print("comparisons for n = 0, 1, 2, 3, 10, 100:", [lis_quadratic(list(range(n)))[2] for n in (0, 1, 2, 3, 10, 100)])
print("edge cases: empty", lis_quadratic([])[0], "| single", lis_quadratic([5])[0], "| all equal", lis_quadratic([2, 2, 2])[0],
      "(non-strict would give", str(lis_quadratic([2, 2, 2], strict=False)[0]) + ") | descending", lis_quadratic([5, 4, 3])[0])

random.seed(2)
for _ in range(400):
    n = random.randint(0, 9)
    a = [random.randint(0, 6) for _ in range(n)]      # small range forces many duplicates
    want = brute(a)
    assert lis_quadratic(a)[0] == want == recursive(a)[0] == memoized(a)[0]
    assert lis_quadratic(a, strict=False)[0] == brute(a, strict=False)
print("400 random arrays with many duplicates: DP, recursion and memoized agree with brute force")

Output:

tiny array: [3, 1, 2, 4]
  i = 0  a[i] = 3  smaller earlier values at j = []  dp[i] = 1
  i = 1  a[i] = 1  smaller earlier values at j = []  dp[i] = 1
  i = 2  a[i] = 2  smaller earlier values at j = [1]  dp[i] = 2
  i = 3  a[i] = 4  smaller earlier values at j = [0, 1, 2]  dp[i] = 3
dp: [1, 1, 2, 3]  answer: 3  comparisons: 6
array: [10, 9, 2, 5, 3, 7, 101, 18]
  i = 0  a[i] = 10  smaller earlier values at j = []  dp[i] = 1
  i = 1  a[i] = 9  smaller earlier values at j = []  dp[i] = 1
  i = 2  a[i] = 2  smaller earlier values at j = []  dp[i] = 1
  i = 3  a[i] = 5  smaller earlier values at j = [2]  dp[i] = 2
  i = 4  a[i] = 3  smaller earlier values at j = [2]  dp[i] = 2
  i = 5  a[i] = 7  smaller earlier values at j = [2, 3, 4]  dp[i] = 3
  i = 6  a[i] = 101  smaller earlier values at j = [0, 1, 2, 3, 4, 5]  dp[i] = 4
  i = 7  a[i] = 18  smaller earlier values at j = [0, 1, 2, 3, 4, 5]  dp[i] = 4
dp: [1, 1, 1, 2, 2, 3, 4, 4]  answer = max(dp): 4  inner-loop comparisons: 28  n(n-1)/2 = 28
brute force: 4  recursion (value, calls): (4, 108)  memoized (value, calls): (4, 62)
recursion calls on 1..n (root counted), n = 0..5: [1, 3, 7, 15, 31, 63]
comparisons for n = 0, 1, 2, 3, 10, 100: [0, 0, 1, 3, 45, 4950]
edge cases: empty 0 | single 1 | all equal 1 (non-strict would give 3) | descending 1
400 random arrays with many duplicates: DP, recursion and memoized agree with brute force

A four-element table by hand

Take [3, 1, 2, 4]. Index 0 (the 3) has nothing before it, so dp[0] = 1. Index 1 (the 1) has no smaller earlier value (3 is not smaller), so dp[1] = 1. Index 2 (the 2) has one smaller earlier value, the 1 at j = 1, so dp[2] = 1 + dp[1] = 2. Index 3 (the 4) sees j = 0, 1, 2 with dp values 1, 1, 2, so dp[3] = 1 + 2 = 3, for the subsequence 1, 2, 4. The first lines of the output print exactly this: dp is [1, 1, 2, 3] and the answer is 3.

Running it on [10, 9, 2, 5, 3, 7, 101, 18]

The trace is printed by the code. Values 10, 9 and 2 have no smaller earlier value, so each gets 1. The value 5 has one smaller earlier value (the 2 at j = 2), so dp = 1 + dp[2] = 2; the value 3 does the same. The value 7 sees j = 2, 3, 4 with dp values 1, 2, 2, so dp = 1 + 2 = 3. The value 101 sees every earlier index, the best dp among them being 3, so it gets 4, and 18 does too. The answer max(dp) is 4. Two subsequences of that length are 2, 5, 7, 101 and 2, 3, 7, 18.

Why the cost is quadratic

Every one of the n positions scans all earlier positions, so the inner loop runs 0 + 1 + ... + (n-1) = n(n-1)/2 times: 28 comparisons for n = 8 (counted by the code), and 0, 0, 1, 3, 45 and 4950 for n = 0, 1, 2, 3, 10 and 100. Stated as states times work per state: n states, each doing up to n comparisons, so O(n^2) time. Space is O(n) for the dp list; there is no recursion in the tabulated version.

Edge cases and common mistakes

• Empty array returns 0, a single element returns 1, a strictly descending array returns 1.
• Equal values: with strict increase [2, 2, 2] gives 1; using <= instead of < (a non-decreasing subsequence) would give 3. Read the problem for which one is wanted.
• Returning dp[n-1] instead of max(dp) is wrong: for [1, 2, 3, 0] the last element ends a subsequence of length 1.
• Initialising dp to 0 loses the element itself; the base value is 1.
• Confusing subsequence with subarray (contiguous) changes the problem entirely.

The 400 seeded random arrays use values 0 to 6 on purpose, so duplicates are common, and the strict and non-strict versions both match try-every-subsequence.

Running the code

Save the listing as lis.py in the current directory, then run:
docker run --rm -v "$PWD":/w -w /w python:3.12 python lis.py

Python 3.12, standard library only.

Direct answer

Quantization (representing weights and activations with fewer bits, such as 8-bit integers instead of 32-bit floats) is the cheaper first move: no retraining, and a small, well-characterized accuracy cost for a large memory and speed win. Distillation (training a smaller "student" model to mimic a larger "teacher") costs more engineering time but can recover more accuracy at a given size. Often you do both: distill to a smaller architecture, then quantize the result.

Structured elaboration

Quantization: changes numeric precision only, a calibration pass not a retrain, hours not days; 32-bit to 8-bit is a 4x memory reduction, with accuracy risk growing below 8-bit.

Distillation: changes architecture and parameter count, trained against the teacher's soft labels, days not hours plus a new evaluation cycle; preserves more accuracy per parameter than numeric coarsening alone.

Worked example

Original model 400MB in 32-bit floats, budget 100MB, baseline accuracy 92%, tolerance under 2 points. Quantizing to 8-bit:

$\text{size}_{\text{int8}} = \frac{400\text{MB}}{4} = 100\text{MB}$

exactly hits budget, and 8-bit post-training quantization commonly costs under 1 point, landing near 91-91.5%. If the measured drop is larger, say 88% (4 points, over budget), distill first to a 120MB float32 student, then quantize it:

$\text{size}_{\text{student-int8}} = \frac{120\text{MB}}{4} = 30\text{MB}$

comfortably inside budget, with the accuracy cost spent on a distillation step you can iterate on, not on coarsening you cannot.

Trade-offs and pitfalls

Quantization is fast but its accuracy hit is hard to fully control below 8-bit; distillation gives more control but is a multi-day project that may not converge on rare classes. A common pitfall is checking only aggregate accuracy and missing that compression hurt one rare, high-stakes class far more than average.

What the interviewer probes next

Checking per-class accuracy degradation rather than the aggregate, post-training quantization versus quantization-aware training, and how target hardware (INT8 kernel support) changes the plan.

The idea in plain words

"Probability proportional to weight" means that if the weights are 3, 1, 4, 1, 5 (total 14), item e is picked with probability 5/14. A direct way to pick: draw a random whole number r from 0 to total - 1, lay the items out on a number line with item i owning a stretch of weight[i] consecutive positions, and return the item whose stretch contains r. The whole problem is finding that item fast while weights keep changing.

A binary sum tree does both parts in O(log n). Put the weights in the leaves of a binary tree (leaves are nodes with no children), and let every internal node store the sum of its two children. The root then holds the total. To find the owner of position r, start at the root and ask "is r inside the left child's stretch?": if r < left sum, go left; otherwise subtract the left sum from r and go right. One decision per level, so the walk takes as many steps as the tree has levels. To change a weight, add the difference to the leaf and to each of its ancestors, again one step per level. Heights and depths here count edges (empty tree -1, single node 0), so a tree with 8 leaves has height 3.

Weights here are non-negative integers, which makes the arithmetic exact; for decimal weights, scale them to integers first. Each update adds a difference to the ancestors, and with floating-point numbers the rounding can leave a tiny nonzero residue in a node whose true weight is 0, so a descent can then return a zero-weight item.

Brute force and the alternatives

• Linear scan: add weights until the running total passes r. Sampling is O(n), updates are O(1).
• Prefix-sum array (cumulative totals [3, 4, 8, 9, 14]): sampling is O(log n) with a binary search, but changing one weight changes every cumulative value after it, so an update is O(n).
• Heap: a heap keeps the largest (or smallest) item at the top and says nothing about sums of subtrees. It is the wrong tool for "pick in proportion to weight". (Heaps do appear in weighted sampling without replacement from a stream, where each item gets a random key built from its weight and a heap keeps the best k keys. That is a rarely asked extension and a different task from sampling from a changing table.)
• Sum tree or Fenwick tree: O(log n) for both operations.

The layout

The tree lives in a flat list. With size leaves (a power of two), leaf i is at index size + i, and the children of node j are 2j and 2j + 1. The five weights above, padded to 8 leaves, look like this (node numbers are the list indexes):

              1:14
          /          \
       2:9            3:5
      /    \         /    \
    4:4    5:5     6:5    7:0
    / \    / \     / \    / \
   3   1  4   1   5   0  0   0
   a   b  c   d   e

The root holds 14. The list is printed by the program below as [0, 14, 9, 5, 4, 5, 5, 0, 3, 1, 4, 1, 5, 0, 0, 0]; index 0 is unused.

Code

import random


class WeightedSampler:
    """Binary sum tree in an array. Leaf i is at size + i; each internal node holds the sum of
    its two children, so tree[1] is the total weight. Weights are non-negative integers."""

    def __init__(self, capacity=4):
        self.size = 1
        while self.size < capacity:
            self.size *= 2
        self.tree = [0] * (2 * self.size)
        self.items = []

    def add(self, item, weight):
        if len(self.items) == self.size:
            self._grow()
        self.items.append(item)
        self.update(len(self.items) - 1, weight)

    def update(self, index, new_weight):
        if not 0 <= index < len(self.items):
            raise IndexError(index)
        if new_weight < 0:
            raise ValueError("weight must be >= 0")
        node = self.size + index
        delta = new_weight - self.tree[node]
        while node >= 1:                          # add the change to every ancestor
            self.tree[node] += delta
            node //= 2

    def _grow(self):                              # doubles the leaf level and rebuilds sums
        leaves = self.tree[self.size:self.size + len(self.items)]
        self.size *= 2
        self.tree = [0] * (2 * self.size)
        self.tree[self.size:self.size + len(leaves)] = leaves
        for node in range(self.size - 1, 0, -1):
            self.tree[node] = self.tree[2 * node] + self.tree[2 * node + 1]

    def total(self):
        return self.tree[1]

    def find(self, r, log=None):
        """Index of the leaf that owns position r, for 0 <= r < total."""
        node = 1
        while node < self.size:
            left = self.tree[2 * node]
            if r < left:
                node = 2 * node
                where = "left"
            else:
                r -= left
                node = 2 * node + 1
                where = "right"
            if log is not None:
                log.append(f"  at node {node // 2} (left sum {left}): go {where}, r is now {r}")
        return node - self.size

    def sample(self, n, rng):
        if self.total() == 0:
            raise ValueError("no weight to sample from")
        return [self.items[self.find(rng.randrange(self.total()))] for _ in range(n)]


class Fenwick:
    """Fenwick (binary indexed) tree over the same weights: n + 1 slots instead of 2 * size."""

    def __init__(self, weights):
        self.n = len(weights)
        self.t = [0] * (self.n + 1)
        for i, w in enumerate(weights):
            self.add(i, w)

    def add(self, i, delta):
        i += 1
        while i <= self.n:
            self.t[i] += delta
            i += i & -i

    def find(self, r):
        """Smallest index whose running total exceeds r."""
        pos, step = 0, 1 << self.n.bit_length()
        while step:
            nxt = pos + step
            if nxt <= self.n and self.t[nxt] <= r:
                pos = nxt
                r -= self.t[nxt]
            step >>= 1
        return pos


if __name__ == "__main__":
    s = WeightedSampler()
    for name, w in [("a", 3), ("b", 1), ("c", 4), ("d", 1), ("e", 5)]:
        s.add(name, w)
    print("capacity", s.size, "| tree array:", s.tree)
    print("node 1 = total", s.total(), "| node 2 =", s.tree[2], "(leaves a..d) | node 3 =", s.tree[3], "(leaves e..h)")

    log = []
    idx = s.find(9, log)
    print("find(9):")
    print("\n".join(log))
    print("-> index", idx, "item", s.items[idx])

    # Exact check: over r = 0..total-1 every leaf must own exactly `weight` positions
    def check(sampler):
        owned = [0] * len(sampler.items)
        for r in range(sampler.total()):
            owned[sampler.find(r)] += 1
        assert owned == sampler.tree[sampler.size:sampler.size + len(sampler.items)], owned
        return owned
    print("positions owned per item:", check(s))

    s.update(1, 6)                    # b goes from 1 to 6
    s.update(2, 0)                    # c goes from 4 to 0, so it must never be returned
    s.add("f", 2)
    s.add("g", 0)
    s.add("h", 7)
    s.add("i", 3)                     # the ninth item forces the tree to double
    print("after updates, capacity", s.size, "| owned per item:", check(s))

    fen = Fenwick(s.tree[s.size:s.size + len(s.items)])
    assert all(fen.find(r) == s.find(r) for r in range(s.total()))
    print("Fenwick find agrees with the sum tree on all", s.total(), "positions")

    rng = random.Random(42)
    draws = s.sample(20000, rng)
    counts = {k: draws.count(k) for k in s.items}
    print("20000 draws:", counts)
    print("expected   :", {k: round(20000 * w / s.total()) for k, w in zip(s.items, s.tree[s.size:])})

    # Randomised check against a plain list of weights
    rng = random.Random(9)
    ref, t = [], WeightedSampler(1)
    for step in range(400):
        if not ref or rng.random() < 0.3:
            ref.append(rng.randint(0, 5)); t.add(len(ref) - 1, ref[-1])
        else:
            i = rng.randrange(len(ref)); ref[i] = rng.randint(0, 5); t.update(i, ref[i])
        if sum(ref):
            assert check(t) == ref
    print("random add/update sequence checked against a plain list: 400 steps, final size", len(ref))

    # The two guards: nothing to sample, and a negative weight
    for label, action in [("empty sampler, sample(1)", lambda: WeightedSampler().sample(1, rng)),
                          ("update(0, -1) on the sampler above", lambda: s.update(0, -1))]:
        try:
            action()
        except ValueError as err:
            print(f"{label}: ValueError: {err}")

Output:

capacity 8 | tree array: [0, 14, 9, 5, 4, 5, 5, 0, 3, 1, 4, 1, 5, 0, 0, 0]
node 1 = total 14 | node 2 = 9 (leaves a..d) | node 3 = 5 (leaves e..h)
find(9):
  at node 1 (left sum 9): go right, r is now 0
  at node 3 (left sum 5): go left, r is now 0
  at node 6 (left sum 5): go left, r is now 0
-> index 4 item e
positions owned per item: [3, 1, 4, 1, 5]
after updates, capacity 16 | owned per item: [3, 6, 0, 1, 5, 2, 0, 7, 3]
Fenwick find agrees with the sum tree on all 27 positions
20000 draws: {'a': 2144, 'b': 4418, 'c': 0, 'd': 760, 'e': 3728, 'f': 1477, 'g': 0, 'h': 5284, 'i': 2189}
expected   : {'a': 2222, 'b': 4444, 'c': 0, 'd': 741, 'e': 3704, 'f': 1481, 'g': 0, 'h': 5185, 'i': 2222}
random add/update sequence checked against a plain list: 400 steps, final size 139
empty sampler, sample(1): ValueError: no weight to sample from
update(0, -1) on the sampler above: ValueError: weight must be >= 0

How a sample descends: the trace

find(9) on the tree above (the cumulative totals are 3, 4, 8, 9, 14, so position 9 is the first position owned by e):

1. At node 1 the left child (node 2) holds 9. r = 9 is not below 9, so go right and set r = 9 - 9 = 0.
2. At node 3 the left child (node 6) holds 5. r = 0 < 5, so go left.
3. At node 6 the left child (leaf 12) holds 5. r = 0 < 5, so go left. Node 12 is a leaf: index 12 - 8 = 4, which is e.

That is exactly the three lines the program prints, and the result e matches the layout.

Why it is correct, and checked exhaustively. At each node the left child owns the first left sum positions of that node's stretch and the right child owns the rest, so the decision never loses a position. The check function in the program tries every r from 0 to total - 1 and confirms that item i is returned for exactly weight[i] of them. That exact count (not a random test) is shown after the updates too, where a weight of 0 is owned by zero positions and so can never be sampled. The 20,000-draw run is a fixed-seed illustration: its counts land near the expected counts but are not exact, which is normal for random draws.

Add, update, and sample(n)

• update(index, new_weight): compute the difference, then add it to the leaf and to every ancestor up to the root: one step per level.
• add(item, weight): put the item in the next free leaf and call update. When the leaves are all used, the tree doubles its leaf count and rebuilds every internal sum in O(size). Amortized means the cost averaged over a whole run of operations. A rebuild at capacity 8 costs about 16 steps, but it can only happen again after 8 more adds have filled the new space, so the rebuild work per add stays constant on average even though one unlucky add costs O(n). In the program, the ninth add doubles the capacity from 8 to 16.
• sample(n): n independent draws of r, each followed by a descent: O(n log N) for N items. That is sampling with replacement (the same item can appear twice). Sampling without replacement can be done by setting a drawn item's weight to 0 with update, and restoring it afterwards, O(log N) each.

Fenwick tree comparison

A Fenwick tree (binary indexed tree) stores partial sums in one list of N + 1 slots, using the lowest set bit of the index to decide which range each slot covers (worked in the walk-through below). Updates add the difference to O(log N) slots; the sample step finds the smallest index whose running total exceeds r by testing powers of two from large to small. The program builds one from the same weights and shows that its find returns the same index as the sum tree for all 27 positions. Choose the Fenwick tree when memory matters or you only need prefix sums plus sampling: it uses N + 1 slots instead of 2 * size (roughly 2N to 4N). Choose the explicit sum tree when you want to read a node's subtree total directly, such as to descend to a subtree, to split sampling by region, or to teach and debug.

Fenwick walk-through on the five weights

Three ideas make the Fenwick tree work. The lowest set bit of a number is its rightmost 1 in binary, and i & -i isolates it (for 12 = 1100 it is 4). Slot i (counting from 1) stores the sum of the i & -i weights that end at index i, so slot 4 covers four weights, slot 6 covers two, and every odd slot covers just itself. Adding i & -i to i jumps to the next slot whose range contains i, which is how an update reaches every slot that must change. And 1 << n.bit_length() is the smallest power of two above n (8 for n = 5), the largest jump the descent can try.

weights = [3, 1, 4, 1, 5]
n = len(weights)
t = [0] * (n + 1)          # slot i (1-based) holds the sum of the last (i & -i) weights ending at i


def add(i, delta):
    i += 1                 # convert to 1-based
    while i <= n:
        t[i] += delta
        print(f"    slot {i} ({i:03b}) += {delta}  -> {t[i]}")
        i += i & -i        # i & -i is the lowest set bit of i; adding it jumps to the next slot that covers i


for idx, w in enumerate(weights):
    print(f"add weight {w} at index {idx}:")
    add(idx, w)
print("slots 1..5:", t[1:])
for i in range(1, n + 1):
    low = i & -i
    print(f"slot {i} ({i:03b}): lowest set bit {low}, covers weights at indexes {i - low}..{i - 1} = {sum(weights[i - low:i])}")


def find(r):
    pos, step = 0, 1 << n.bit_length()
    print(f"find({r}): start pos=0, step={step}")
    while step:
        nxt = pos + step
        if nxt <= n and t[nxt] <= r:
            print(f"    step {step}: slot {nxt} holds {t[nxt]} <= r={r}, take it, r becomes {r - t[nxt]}")
            pos, r = nxt, r - t[nxt]
        else:
            print(f"    step {step}: slot {nxt} " + ("is past the end" if nxt > n else f"holds {t[nxt]} > r={r}, skip"))
        step >>= 1
    return pos


print("owner of position 9 is index", find(9))

# growing a sum tree from 2 leaves to 4 when a third weight arrives
size, tree = 2, [0, 4, 3, 1]          # leaves are tree[2:4] = [3, 1]; tree[1] = 4 is the total
print("\nbefore grow:", tree)
leaves = tree[size:]
size *= 2
tree = [0] * (2 * size)
tree[size:size + len(leaves)] = leaves  # copy the leaves into the new, wider leaf level
for node in range(size - 1, 0, -1):     # recompute every internal sum bottom-up
    tree[node] = tree[2 * node] + tree[2 * node + 1]
print("after grow: ", tree)
tree[size + 2] = 4                      # now the third weight fits; add it to the leaf (node 6) and its ancestors (nodes 3 and 1)
tree[3] += 4
tree[1] += 4
print("after adding weight 4 at index 2:", tree)

Output:

add weight 3 at index 0:
    slot 1 (001) += 3  -> 3
    slot 2 (010) += 3  -> 3
    slot 4 (100) += 3  -> 3
add weight 1 at index 1:
    slot 2 (010) += 1  -> 4
    slot 4 (100) += 1  -> 4
add weight 4 at index 2:
    slot 3 (011) += 4  -> 4
    slot 4 (100) += 4  -> 8
add weight 1 at index 3:
    slot 4 (100) += 1  -> 9
add weight 5 at index 4:
    slot 5 (101) += 5  -> 5
slots 1..5: [3, 4, 4, 9, 5]
slot 1 (001): lowest set bit 1, covers weights at indexes 0..0 = 3
slot 2 (010): lowest set bit 2, covers weights at indexes 0..1 = 4
slot 3 (011): lowest set bit 1, covers weights at indexes 2..2 = 4
slot 4 (100): lowest set bit 4, covers weights at indexes 0..3 = 9
slot 5 (101): lowest set bit 1, covers weights at indexes 4..4 = 5
find(9): start pos=0, step=8
    step 8: slot 8 is past the end
    step 4: slot 4 holds 9 <= r=9, take it, r becomes 0
    step 2: slot 6 is past the end
    step 1: slot 5 holds 5 > r=0, skip
owner of position 9 is index 4

before grow: [0, 4, 3, 1]
after grow:  [0, 4, 4, 0, 3, 1, 0, 0]
after adding weight 4 at index 2: [0, 8, 4, 4, 3, 1, 4, 0]

Read the trace like this. Adding weight 3 at index 0 touches slots 1, 2 and 4: the three slots whose ranges include index 0. The table shows slot 4 holds 9 = 3 + 1 + 4 + 1, the first four weights. In find(9) the descent tries the largest jump first: slot 8 does not exist, slot 4 holds 9 which is not above r = 9, so the whole block belongs before the answer and r drops to 0. The next jump lands on slot 6, past the end, and slot 5 holds 5, which is above 0, so the walk stops with pos = 4: index 4, item e, the same owner the sum tree found. The last three lines show the sum tree's growth step on a 2-leaf tree: the leaves are copied into a wider leaf level and every internal sum is recomputed bottom-up.

A typical interview needs one of the two trees (the sum tree or the Fenwick tree), the update rule and the descent rule. The alias method and sampling with random keys and a heap are deeper material that a coding round rarely asks for.

Complexity

• update, find: O(log size) each, where the tree has about log2(size) levels (3 for 8 leaves, 4 for 16).
• add: O(log size) plus an O(size) rebuild each time the capacity doubles: amortized O(log size).
• sample(n): O(n log size).
• Space: a list of 2 * size entries, where size is at most about 2N for N items, so about 4N entries at most.

Edge cases and common mistakes

• Total weight 0: there is nothing to sample; the code raises ValueError instead of returning an item (the last lines of the first program's output show it).
• Zero-weight items must never be returned: use r < left (strict) when choosing the left child, which the exhaustive check confirms.
• Updating a leaf without updating its ancestors leaves every sum above it stale, so the descent is steered by old totals.
• Using floating-point weights and random.random() * total: rounding can send the descent into a zero-weight leaf. Scale to integers or add a guard.
• Off-by-one on the position: randrange(total) yields 0 to total - 1; using randint(0, total) can pick a position past the end.
• Negative weights make the stretches meaningless; reject them as update does (also shown in the last output line of the first program).

Follow-ups and how the answer changes

• Weights never change and the number of draws is huge: the alias method (a precomputed table of two-way coin flips; rarely asked in interviews) gives O(1) per draw after an O(n) setup, but any update means rebuilding.
• Sampling without replacement while weights change: the zero-and-restore trick above, in O(log N) per draw.
• Different sample sizes per call and a stream of items: keep the same tree and only grow the leaf level when needed.

Running the code

# Python 3.12, standard library only
python weighted_sampler.py     # the sampler (first program)
python fenwick_walk.py         # the Fenwick walk-through (second program)

Direct answer

Across images, text, and time-series, augmentation techniques share the same goal (expand effective training diversity without changing the label) but the SAFE transformations differ completely by modality, because what "changes the meaning" versus "doesn't" is modality-specific.

Structured elaboration

For a limited-images-per-class problem specifically, the choice between on-the-fly augmentation (transform fresh, differently, every epoch) and generating an expanded static dataset up front (transform once, save the results, train on the fixed expanded set) matters: on-the-fly gives effectively infinite variety at the cost of recomputing transforms every epoch, while a static expanded dataset is faster to iterate on (compute once) but caps the diversity at whatever you generated, and can itself be re-memorized if it's not large enough.

Production framing for all three modalities: augmentation must preserve the label (the core requirement), respect latency constraints if applied at inference/serving time rather than only during training, and stay semantically valid (a back-translated sentence that changed the actual meaning is worse than no augmentation at all, since it's now training on a wrong-but-plausible-looking example).

Worked example

A time-series jitter augmentation adds small Gaussian noise to each point: $x'_t = x_t + \epsilon_t,\ \epsilon_t \sim \mathcal{N}(0, \sigma^2)$. For sensor data with a genuine physical floor (say, a temperature reading that can't go below absolute zero, or a count that can't go negative), naively applying this can generate physically impossible synthetic values unless the noise scale and any hard bounds are chosen with that constraint in mind.

Trade-offs and pitfalls

The single most common augmentation mistake, across all three modalities, is applying a transformation you haven't actually verified preserves the label, because a "reasonable-sounding" augmentation (horizontal flip, synonym swap, amplitude scaling) can silently be label-changing for a specific task even though it's label-preserving for a different, more common one.

Direct answer

Nightly latency spikes at constant request volume mean the cause is TIME-based, not LOAD-based, which immediately rules out anything that scales with traffic and points toward scheduled work (background jobs, cache expiry/warming cycles, scheduled maintenance) or periodic garbage-collection/compaction cycles that happen to cluster around the same time each night, independent of how many requests are actually arriving.

Structured elaboration

1. Confirm the pattern is genuinely time-correlated, not coincidentally volume-correlated. Check request-volume metrics for the exact spike windows across several nights; if volume is truly flat while latency spikes, that rules out ordinary capacity-driven causes and strongly implicates something scheduled or periodic. Alongside the metrics, pull application-level logs for the exact spike windows specifically (not just the surrounding hours), looking for warning-level entries, retry counts, or error codes clustered in that window that a metrics dashboard alone would not surface.
2. Check for scheduled background jobs running on the same host/cluster around the spike time: a cache-warming job, a log-rotation or compaction task, a batch analytics job sharing infrastructure, a scheduled backup; cross-reference the exact spike timestamps against the cron/scheduler's OWN execution logs (start time, end time, and any error or retry entries for each scheduled run), not just a summary job-history view, since a summary view can round timestamps in a way that obscures a precise correlation.
3. Check caching policies specifically for a periodic expiry pattern. If a cache (in-process or shared) has a TTL (time-to-live: how long a cached entry is kept before it expires) that causes many entries to expire around the same time each night (a fixed-time cache-refresh schedule, or a TTL set relative to a fixed daily reset rather than per-entry insertion time), the resulting simultaneous cache-miss storm can produce exactly this nightly-latency-spike-at-flat-volume signature.
4. Check for batch windows in any request-batching logic; if requests are batched with a time-based flush (rather than purely size-based), and something periodic changes the batch-fill rate at that hour (fewer concurrent requests overnight meaning batches take longer to fill and therefore wait longer before flushing, even at flat OVERALL system load), that's a plausible, easy-to-overlook mechanism, especially ironic since it's a case where LOWER traffic at night could paradoxically increase per-request latency via the batching wait.
5. Check garbage-collection patterns for a scheduled or load-triggered full GC that happens to land at a consistent time nightly (some GC strategies trigger based on heap-growth patterns that, combined with a consistent daily traffic/memory-allocation shape, can cluster around the same hour even without being explicitly scheduled); the runtime's own GC logs (pause duration and frequency per collection cycle, not just an aggregate GC-time metric) show directly whether pause TIMING specifically clusters at the same nightly window, rather than requiring that to be inferred indirectly from latency alone.
6. Check for multi-tenant interference if the infrastructure is shared: another tenant's own scheduled nightly job competing for the same underlying resources (CPU, disk IO, network) can produce a latency spike for YOUR service with zero change to your own traffic or code, visible only by checking host-level (not just your-service-level) resource metrics during the spike window.
7. Check for scheduled maintenance: automated OS patching, container/host restarts, or infrastructure-level maintenance windows that a platform team runs on a schedule independent of any application team's knowledge.

Worked example

Cross-referencing spike timestamps against the platform's job scheduler shows a company-wide log-aggregation/rotation job running nightly on shared infrastructure, and host-level (not service-level) CPU and disk-IO metrics show a clear spike during exactly the same window, confirming multi-tenant interference from that job rather than anything in the service's own code or configuration. Immediate mitigation: request the shared job be rescheduled to a lower-traffic window for this service, or move this service to isolated infrastructure if the interference is severe enough to warrant it; a code-level fix wouldn't have helped at all here, since nothing about the service's own logic was the actual cause.

Trade-offs and pitfalls

The temptation to profile the SERVICE's own code first (since that's what's directly controllable) can waste significant time when the actual cause is external, shared-infrastructure interference invisible to service-level metrics alone; checking host-level, not just service-level, resource metrics during the spike window is often the fastest way to distinguish "something in my own code" from "something external happening to my host," and should be checked early given the flat-volume/time-correlated signature already points away from the service's own request-handling logic.

Direct answer

An online-learning recommendation system updating continuously from millions of users needs monitoring that catches degradation FAST (since a bad update compounds quickly), explicit safety constraints (exposure caps, diversity floors) baked into the serving logic itself, and an auditable trail so any harmful update can be traced and reverted precisely.

Structured elaboration

1. Monitoring for degradation: track rolling, short-window versions of the usual signals (score-distribution stability, diversity of recommendations served, engagement-rate trend) at a MUCH tighter cadence than a batch-retrained system would need, since a continuously-updating model can degrade meaningfully within hours, not days.
2. Safety constraints as guardrails, not just alerts: exposure caps (no single item or narrow category can exceed some maximum share of impressions, regardless of what the model currently believes is optimal) and diversity controls (a minimum floor on recommendation variety) are enforced directly in the SERVING logic, as a hard constraint the model operates within: this is different from an alert that fires after the fact, since these constraints prevent certain bad outcomes from ever being SERVED at all, rather than just detecting them after the harm has already reached users.
3. Rollback and shadow testing for candidate updates: rather than every incremental update going straight to full production, validate candidate updates in shadow first (score live traffic without serving) even in an online-learning setting, and maintain the ability to revert to a specific PRIOR model state (a periodic checkpoint) if a bad update needs undoing: pure online learning without checkpoints makes "rollback" meaningless, since there's no discrete prior state to return to.
4. Offline evaluation of updates: periodically (even if updates themselves are continuous) run a full offline evaluation against a held-out benchmark, to catch a slow, cumulative degradation that no single incremental update looked bad enough to trigger an alert on its own.
5. Auditable records: log enough about each incremental update (what data it trained on, what changed) that a harmful drift can be traced back to roughly WHEN it started accumulating, not just noticed once it's already severe.

Worked example

The algorithm-choice dimension matters here too: for a time-series-like setting with frequent concept drift, adaptive online learners (adaptive random forests, or online gradient boosting with a decay factor on older data) are built to track a moving target more gracefully than a model with no explicit forgetting mechanism, trading some stability for responsiveness, but that responsiveness is exactly what makes the guardrails above non-optional, since a model that adapts FAST to real drift also adapts fast to a bad batch of poisoned or anomalous data.

Trade-offs & pitfalls

The core tension in a continuously-updating system is that the same property that makes it valuable (fast adaptation to real changes) also makes it dangerous (fast adaptation to noise, bugs, or adversarial input): hard guardrails baked into serving, not just monitoring, are what keep the downside bounded while still capturing the upside of genuine responsiveness.

Direct answer: Feature engineering for survival analysis (modeling time-to-event with right-censoring, like time-to-churn) needs to represent both fixed baseline characteristics at the start of observation and genuinely time-VARYING covariates that update as the observation period unfolds, with the preprocessing differing meaningfully between a proportional-hazards-style model and a more flexible tree-based or deep survival model.

Structured elaboration:
Baseline features at time zero: characteristics known at the start of the observation window (signup date, initial plan type), which are static for the duration of that entity's observation. Time-varying covariates: features that genuinely change during the observation period (a rolling engagement count, updated at each time step) need to be represented as a SEQUENCE of values over time, not a single snapshot, since the whole point of survival analysis with time-varying covariates is capturing how CHANGES in behavior relate to the hazard of the event occurring.

Preprocessing differences by model: a Cox proportional-hazards model has specific structural assumptions (the proportional-hazards assumption itself, and typically a linear combination of covariates) that constrain how time-varying covariates can be incorporated (often requiring the data to be reshaped into a specific "counting process" format with one row per covariate-change interval); a random survival forest or a deep survival model (like DeepSurv) can generally handle time-varying covariates more flexibly and doesn't require the same structural linearity or proportional-hazards assumption, at the cost of typically needing more data to fit reliably and being less directly interpretable.

Worked example: For a subscription-churn survival model, a baseline feature might be the customer's initial plan tier (fixed at signup), while a time-varying covariate is their rolling 30-day engagement score, updated at each observation interval; reshaped into the counting-process format a Cox model needs, each customer contributes multiple rows, one per interval during which their covariates stayed constant, with the model then estimating how a CHANGE in the time-varying engagement score relates to the instantaneous hazard of churning at that point, which a single-snapshot feature representation could never capture.

Trade-offs and pitfalls: The temptation to simplify by using only baseline (time-zero) features and ignoring genuine time-variation loses exactly the signal that's often most predictive in a survival context (a RECENT change in behavior, not the initial state, frequently drives the actual event), so the added complexity of properly representing time-varying covariates is usually worth its engineering cost for this class of problem specifically.

Direct answer

Give the auditor an evidence pack that answers each question with a specific artifact: a register of personal data (where it is stored), a data-flow diagram (how it moves), an access matrix (who can reach it), audit logs with correlation ids (a unique id stamped on every log line of one request, so the lines can be joined into one story) that show what happened and when, and lineage records (a record of where a result came from: which model version and data produced it) tying a prediction or transaction back to the exact model version and data. Show the boundaries that matter (card data, and residency regions, meaning the places where rules require personal data to stay) on the diagrams, and show where personal data is redacted. Core for every audit: the register, the data-flow diagram, the access matrix and the audit log. Add the card-data boundary only if you handle card payments, and the lineage record only if models make decisions.

Evidence pack: question to artifact

Diagram elements to include

• Data stores with classification labels (personal, payment, public).
• Trust boundaries and the residency regions:

flowchart LR
  C[Customer] --> R[Edge router picks region by customer home region]
  R --> A1
  R --> A2
  subgraph EU[EU region]
    A1[App services] --> D1[(EU customer database)]
    A1 --> L1[(EU audit log)]
  end
  subgraph US[US region]
    A2[App services] --> D2[(US customer database)]
    A2 --> L2[(US audit log)]
  end
  D1 -.->|aggregated non-personal metrics only| W[Global analytics warehouse]
  D2 -.->|aggregated non-personal metrics only| W

Also mark where backups live and that they stay in the same region.

• Payment data: the cardholder data environment (the systems that store, process or transmit card data under PCI DSS, the payment card industry security standard) drawn as its own boundary. Mark where the PAN (primary account number, the full card number) is tokenised (swapped for a random stand-in value that is useless without a separate, tightly guarded lookup), and show that logs receive only the token.
• Redaction points: mark where personal identifiers (PII, personally identifiable information) are masked or dropped before reaching logs, analytics or support tools.
• Audit trail: an immutable log store (append-only, restricted write and read) recording who accessed which record, when and why, including access to card and personal data.

Traceability for predictions (ML)

Every prediction writes a lineage record so an auditor can walk backwards from one decision:

{
  "prediction_id": "pred-88213",
  "transaction_id": "T-1001",
  "correlation_id": "req-5f3a91",
  "timestamp": "2026-09-28T09:15:02Z",
  "model_name": "fraud-scorer",
  "model_version": 14,
  "feature_set_version": 6,
  "training_data_snapshot": "2026-08-01",
  "input_hash": "sha256 of the feature values",
  "score": 0.83,
  "decision": "manual_review",
  "region": "EU"
}

Read it like this: transaction T-1001 got score 0.83 from fraud-scorer version 14, which used feature set 6 (the versioned list of input fields and how each is calculated) and was trained on the 2026-08-01 snapshot (a frozen copy of the training data as of that date). The model registry (the catalogue of trained model versions) then shows who approved version 14 and its evaluation, and the audit log shows who viewed the case. Store the input hash (a fixed-length fingerprint of the inputs made with the SHA-256 algorithm: the same inputs always give the same fingerprint, so you can show what was scored without keeping the raw values) rather than raw personal values when the raw data is not needed, and keep the record for the retention period.

Worked walk-through for the auditor: pick transaction T-1001; find its dataset in the register (region, retention, owner); find the audit log entry by correlation id (req-5f3a91, which the lineage record also carries, so the two join); open the lineage record; open the registry entry for version 14; show the access matrix row for who could see the case. Five artifacts, one trace.

Pitfalls: a diagram that shows the design but not the deployed system; logging raw card numbers or emails "for debugging"; residency drawn for primary databases but forgotten for backups and caches; lineage that records the model name but not the version.

Direct answer

Ordinary least squares (OLS) assumes: (1) linearity of the mean relationship, (2) independence of errors, (3) homoscedasticity (constant error variance), (4) no perfect multicollinearity among predictors, and, only if you need exact small-sample inference, (5) normally distributed errors. The first four are about getting unbiased, well-behaved coefficient estimates; the fifth is about trusting the p-values and confidence intervals you compute from them.

Structured elaboration

Two things worth being precise about. First, OLS point estimates are unbiased under just linearity and mean-zero, uncorrelated errors, homoscedasticity is only needed for the standard variance formula $\sigma^2(X^\top X)^{-1}$ to be correct, not for unbiasedness. Second, the diagnostics form a natural order: check linearity first, because a mis-specified mean can itself produce a curved or fanned residual plot that looks like heteroscedasticity but is really a wrong functional form.

Worked example

Simulate $y = 2.0 + 1.5x + \varepsilon$ where $\varepsilon$'s standard deviation grows with $x$ (a textbook heteroscedasticity case), fit OLS, then run the auxiliary regression the Breusch-Pagan test is built on (regress squared residuals on the predictor):

import numpy as np
np.random.seed(0)
n = 500
x = np.random.uniform(1, 10, n)
noise = np.random.randn(n) * (0.3 * x)      # std scales with x: heteroscedastic
y = 2.0 + 1.5 * x + noise

X = np.column_stack([np.ones(n), x])
beta_hat = np.linalg.solve(X.T @ X, X.T @ y)          # [1.893, 1.491], close to [2.0, 1.5]
resid = y - X @ beta_hat

Xr = np.column_stack([np.ones(n), x])
gamma = np.linalg.solve(Xr.T @ Xr, Xr.T @ (resid**2))
pred = Xr @ gamma
r2_bp = 1 - np.sum((resid**2 - pred)**2) / np.sum((resid**2 - resid.var())**2)
lm_stat = n * r2_bp                                   # ~ chi-square(1) under homoscedasticity

This runs (verified) to beta_hat = [1.893, 1.491], close to the true [2.0, 1.5], and an auxiliary $R^2 = 0.137$, giving an LM statistic of 68.4 against a $\chi^2(1)$ reference, a p-value on the order of $10^{-16}$. Coefficients are still roughly unbiased, exactly as the theory predicts (homoscedasticity isn't needed for that), but the test flags, correctly and decisively, that the default OLS standard errors are wrong here.

A second check, separately, on multicollinearity:

np.random.seed(1)
n2 = 300
x1 = np.random.randn(n2)
x2 = 0.95*x1 + 0.05*np.random.randn(n2)   # near-collinear with x1
x3 = np.random.randn(n2)                  # independent

def vif(Xmat, j):
    y_j = Xmat[:, j]
    Xother = np.delete(Xmat, j, axis=1)
    Xother = np.column_stack([np.ones(n2), Xother])
    beta = np.linalg.solve(Xother.T @ Xother, Xother.T @ y_j)
    pred = Xother @ beta
    r2 = 1 - np.sum((y_j-pred)**2) / np.sum((y_j-np.mean(y_j))**2)
    return 1/(1-r2)

Xvif = np.column_stack([x1, x2, x3])
vifs = [vif(Xvif, j) for j in range(3)]

Running this (verified) gives vifs = [293.97, 294.10, 1.01]: the near-collinear pair comes back with VIF around 294 for both, versus 1.01 for the independent column, exactly the "blows up" signature VIF is meant to catch.

Trade-offs & pitfalls

• Don't diagnose in the wrong order: a curved residual plot from a mis-specified mean can masquerade as fanning variance. Fix the functional form first, then re-check for heteroscedasticity on the corrected model.
• A VIF threshold of 10 is a convention, not a law. In some fields (e.g. survey data with many derived variables) even VIF of 5 is treated as a problem; judge it against how unstable your specific coefficients get.
• Normality of errors is the assumption most often over-weighted. With even a moderately large sample, the coefficient estimates are approximately normal by the central limit theorem regardless, so a failed Q-Q plot on the residuals is rarely a reason to abandon OLS outright.
• Heteroscedasticity-robust standard errors fix your inference but not your efficiency: OLS is no longer the minimum-variance estimator once errors are heteroscedastic, weighted least squares can do better if you know (or can estimate) the variance structure.