Microsoft AI Engineer (Entry Level) - Comprehensive Interview Preparation Guide

Definition and key differences:

• Array: ordered, indexable collection allowing duplicates. Good for ordered iteration, random access by index, and operations like map/filter/reduce.
• Set: ES6 collection of unique values (based on SameValueZero equality), preserves insertion order but has no numeric indices. Ideal when uniqueness is primary.

Membership test performance:

• Array: indexOf/includes is O(n) average — scans items.
• Set: has(value) is on average O(1) (hash-backed semantics in engines). For many membership checks (e.g., filtering tokens against a stoplist), Set is significantly faster.

Deduplication while preserving order:

• Sets preserve insertion order, but constructing a Set from an Array removes duplicates and keeps the first occurrence order. Example:

// preserve first occurrence order
const arr = ['a','b','a','c','b'];
const deduped = Array.from(new Set(arr)); // ['a','b','c']

If you need to keep last occurrence instead, iterate in reverse:

const arr = ['a','b','a','c','b'];
const seen = new Set();
const reversedKeepLast = [];
for (let i = arr.length - 1; i >= 0; i--) {
  if (!seen.has(arr[i])) {
    seen.add(arr[i]);
    reversedKeepLast.push(arr[i]);
  }
}
const result = reversedKeepLast.reverse(); // keeps last occurrences in original order

Converting between Array and Set:

• Array -> Set: new Set(array)
• Set -> Array: Array.from(set) or [...set]

Trade-offs for token pipelines (AI Engineer context):

• Use Set when:
  • You need fast membership tests (stopwords, seen-token deduplication) at scale.
  • Uniqueness is required and order is either insertion-based or irrelevant.
  • Memory cost of deduplicated set is acceptable.
• Use Array when:
  • Token order, positional indices, or duplicates matter (e.g., language models relying on token positions, n-gram counts).
  • You need array methods (map/filter) that implicitly rely on indices or stable iteration patterns.
• Practical hybrid patterns:
  • Keep tokens as Array for modeling but use a Set for auxiliary operations (e.g., seen = new Set(); filter tokens by checking seen.has(token) to remove duplicates while building an array).
  • For large vocab/token streams, prefer Sets for seen-checks to avoid O(n^2) behavior.

Example in a pipeline removing duplicate tokens while preserving first order:

function dedupeTokens(tokens) {
  const seen = new Set();
  const out = [];
  for (const t of tokens) {
    if (!seen.has(t)) {
      seen.add(t);
      out.push(t);
    }
  }
  return out;
}

Summary: Arrays for ordered sequences and model inputs; Sets for fast uniqueness and membership checks. Combine both to get best performance and semantics in token pipelines.

Direct answer

Once you know a partner function is measured on something different from you (speed versus quality or risk, for example), you scope your asks to be small and cheap under their metric, and you change what "status" means when you talk to them: short, action-oriented signals instead of the detailed risk narrative you'd give your own stakeholders. You're not changing what you need, you're changing how you package it so it doesn't read as a tax on the thing they're rewarded for.

Structured elaboration

1. Diagnose the incentive, don't assume it. Confirm what the partner function is actually measured on (deploy velocity, ticket close time, uptime, cost) rather than inferring it from how they push back. Different sub-teams within the "same" function can be measured differently.
2. Scope the ask to the smallest unit that gets you what you need. If they're speed-measured, don't ask for a broad, standing review of everything; ask for a narrow, well-bounded check on the specific surface that carries the risk you actually care about, and let everything else pass without friction.
3. Translate the ask into their currency. Instead of framing a request around your risk language, frame it around what it costs (or saves) them in their terms: incident response hours avoided, rework avoided, a compliance gate they'd otherwise hit later and more expensively.
4. Change the shape of status, not just the ask. For a speed-measured partner, give a compact signal (blocked/not blocked, a count, a single risk flag) they can act on in seconds. Save the fuller narrative for your own stakeholders who need the detail. Sharing the same long-form update with both audiences under-serves the partner who needs to move fast.
5. Keep a floor. Adapting your ask to their incentive has a limit: there's a minimum you can't compromise below without failing your own mandate. Know that floor before the conversation so "scoping down" doesn't quietly become "giving up the requirement."
6. Revisit as trust builds. Early asks are necessarily narrow and low-trust. As the partner sees your asks are well-scoped and your status updates are reliable, you can often widen the ask (a slightly broader review surface, more lead time) because they've learned you're not going to slow them down for nothing.

Worked example

A platform team is measured on release velocity; a security-minded partner function is measured on defect and incident rates. Rather than asking the platform team to route every change through manual security review (a direct tax on their velocity metric), the ask is scoped to only changes that touch a named risk surface, such as authentication or payment code. Everything else ships without added friction. Status to the platform team is a single weekly line: "2 changes in the review queue, 0 blocking, both cleared by Thursday." The fuller write-up, with rationale and residual risk, goes to the security function's own leadership, not to the platform team, because that's not the audience that needs it to act.

Trade-offs & pitfalls

• Pitfall: scoping the ask down so far it stops actually managing the risk it exists to manage. Know your floor before you negotiate.
• Pitfall: assuming the incentive instead of confirming it. Guessing wrong (e.g., treating a team as purely speed-driven when they're also on the hook for a compliance metric) leads to asks that miss what would actually land.
• Pitfall: sending the same status update to every audience. It either over-informs the speed-measured partner (who tunes it out) or under-informs your own stakeholders (who need the detail to make decisions).
• Senior differentiator: treating the ask size and the status format as things you design deliberately around the incentive gap, and revisiting that design as trust changes, rather than a fixed communication style you use with everyone.

Direct answer

Lead with what you were moving toward, a pull factor tied to this role, and if a negative factor is genuinely relevant, describe the situation factually rather than characterizing people. The test: would your former manager watch the answer back and call it fair.

The framework

1. Lead forward: state the pull reason first, something concrete you wanted more of (scope, a kind of problem, a growth path), and connect it directly to why this role fits.
2. If asked directly about a push factor, describe the situation, not the people: what happened structurally (a reorg, a roadmap shift, a mismatch in scope), not adjectives about anyone's competence or character.
3. Keep any negative context to one factual sentence, then pivot back to the forward-looking reason; dwelling signals unresolved frustration more than it signals honesty.
4. Special cases (a layoff, a performance-related departure) deserve the same treatment: state it plainly and briefly, then move to what you learned or want next; over-explaining reads worse than a short, honest sentence.

Worked example

I spent three years building a defined area of ownership and grew that scope significantly, but the team's roadmap shifted toward a different area over the last year, and the kind of work I wanted more of wasn't where the team was headed. I'm looking for a role like this one specifically because it's built around the kind of scope and problem I want, which is exactly the direction I wanted to keep growing in.

Trade-offs and pitfalls

The fairness test catches both failure modes: if the answer would embarrass you should your former manager see it, it's too negative; if it's so vague it sounds like something's being hidden, it's not honest enough.

To perform an iterative inorder traversal (left, root, right) without recursion, use an explicit stack to simulate the call stack: keep pushing left children until None, then pop a node, process it, and move to its right child. This handles empty trees gracefully.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def inorder_iterative(root):
    """
    Return list of node values in inorder using an explicit stack.
    Handles empty tree (root is None) by returning [].
    """
    res = []
    stack = []
    curr = root

    # Traverse until all nodes processed
    while curr or stack:
        # Go as far left as possible
        while curr:
            stack.append(curr)
            curr = curr.left
        # Visit node
        node = stack.pop()
        res.append(node.val)
        # Explore right subtree
        curr = node.right

    return res

# Example:
#   2
#  / \
# 1   3
# inorder_iterative(root) -> [1,2,3]

Key points:

• Time complexity: O(n) — each node pushed/popped/visited once.
• Extra space: O(h) where h is tree height (stack size). Worst-case skewed tree: h = n → O(n) extra space.
• Pitfalls: deeply skewed trees degrade to O(n) stack usage; although this avoids Python recursion depth limits, it still uses linear memory and can be expensive for very deep trees. Consider tail-recursive patterns or tree rebalancing (or Morris traversal for O(1) extra space) if constant extra space is required, but Morris modifies tree pointers temporarily.

Training vs Inference - primary functional and resource differences

1. Compute patterns

• Training: heavy both forward and backward passes. Backprop requires computing gradients for every parameter (multiply by ~2–3x FLOPs (floating-point operations) vs forward-only), plus optimizer updates.
• Inference: only forward passes (matrix multiplies, activation functions). Much lower FLOP count per example.

2. Memory usage

• Training: large memory for activations (needed for backprop), gradients, and optimizer state (e.g., Adam stores moment estimates: 2× parameters). Batch sizes amplify activation memory.
• Inference: memory dominated by model weights and transient activations for the forward pass; no gradient or optimizer state.

3. Latency vs throughput goals

• Training: maximize throughput (samples/sec, epoch time) and resource utilization. Latency per sample is less critical.
• Inference: often strict latency (ms-level) for real-time services; sometimes prioritize high throughput for batch/async serving.

4. Data requirements

• Training: large labeled (or unlabeled for self-supervised) datasets, heavy I/O and preprocessing. Data sharding, augmentation and epoch management matter.
• Inference: single inputs or small batches; input preprocessing must be low-latency.

5. Optimization priorities

• Training: optimize GPU utilization, mixed precision (FP16/AMP), large batches, gradient accumulation, distributed training (data/model parallelism), checkpointing and fault tolerance.
• Inference: optimize latency and cost - quantization (INT8), pruning, kernel fusion, model distillation, batching strategies, CPU/GPU deployment or specialized accelerators (TPU/NPUs).

Concrete example - BERT

• Fine-tuning BERT: training stage uses forward+backprop across entire model; stores activations for transformer layers; uses Adam optimizer (2× parameter memory); run on multi-GPU/TPU with large batch sizes and mixed precision to speed convergence.
• Serving BERT: forward-only; can be distilled or quantized; deploy on CPU for high-concurrency low-cost cases or on GPU/accelerator for low-latency endpoints. Techniques: sequence-length optimization, dynamic batching, ONNX/TensorRT compilation.

Hardware & architecture implications

• Training: requires high-memory GPUs/TPUs, NVLink/PCIe for fast inter-GPU gradients, high-bandwidth memory (HBM), fast storage and network for dataset throughput.
• Inference: favors many smaller servers/edge accelerators, low-power NPUs, CPU vector instructions, and model-serving stacks with autoscaling and caching.

Takeaway: training is compute- and memory-intensive with throughput focus; inference is lightweight per-example but demands low latency and cost-effective deployment; these differences dictate different optimizations, runtimes, and hardware choices.

Direct answer
try marks a block whose exceptions you want to intercept; except runs only if a matching exception is raised inside the try; finally always runs, whether or not an exception occurred and whether or not it was caught, and it runs even if the exception propagates past this block entirely.

Structured elaboration

• No exception: the try block runs to completion, every except clause is skipped, then finally runs. Nothing unusual happens.
• Exception raised and caught: execution jumps out of the try block the instant the exception is raised (any code after the raising line in try does NOT run), the first matching except clause runs, then finally runs.
• Exception raised and NOT caught (no except clause matches its type): the matching-except search fails, finally still runs (this is the part people get wrong: finally is not conditional on being caught), and only after finally completes does the exception continue propagating up to the caller.
• The consequence that matters in practice: finally is the correct place for resource cleanup that must happen unconditionally, closing a file handle, releasing a lock, rolling back a partially-started operation, precisely because it is the one block guaranteed to run on every exit path from the try.

Worked example

def no_exception():
    order = []
    try:
        order.append('try')
    except ValueError:
        order.append('except')
    finally:
        order.append('finally')
    return order

def caught_exception():
    order = []
    try:
        order.append('try')
        raise ValueError('boom')
    except ValueError:
        order.append('except')
    finally:
        order.append('finally')
    return order

Running both (verified): no_exception() returns ['try', 'finally'] (the except clause never runs), caught_exception() returns ['try', 'except', 'finally']. A third case with a TypeError raised where only ValueError is caught confirms finally still runs before the TypeError propagates out to the caller, exactly as described above.

For the file-I/O case, opening a file and guaranteeing it closes even on a mid-read failure:

def read_lines(path):
    f = open(path, 'r')
    try:
        return f.readlines()
    finally:
        f.close()   # runs whether readlines() succeeds, raises, or the caller's except re-raises

This is exactly what a with open(path) as f: block (or Java's try-with-resources) does under the hood, they are sugar over a try/finally that closes the resource. In this pattern, whether to re-raise the error after logging it or return a sentinel value to the caller depends on whether the caller can meaningfully continue: propagate (let the exception continue, possibly after logging) when the caller cannot proceed without the data; return a sentinel only when the caller has a genuine, documented fallback.

Trade-offs & pitfalls
The most common mechanical mistake is assuming finally only runs when an exception was caught, when in fact it runs on every exit from try (normal completion, caught exception, uncaught exception, even a return inside the try block). The second most common mistake is putting cleanup code after the try/except instead of in finally, which silently skips cleanup on any path that doesn't hit that exact line, exactly the bug that finally exists to prevent.

Direct answer
Cutting a document in half without losing the point means removing words and sentences that restate, hedge, or elaborate past the level of detail the reader needs, not removing content the reader actually needs. Start by identifying the load-bearing sentences, then cut everything else, then tighten what's left.

Structured elaboration

1. Identify the load-bearing sentences first. For each paragraph, ask: if this sentence disappeared, would the reader miss information they need to act? Mark the ones that survive that test.
2. Cut whole sentences before trimming words. Removing a redundant sentence saves more length, with less risk of losing meaning, than trying to shave words from every sentence.
3. Common categories to cut entirely: sentences that restate a point already made in different words; hedging phrases ("it is worth noting that," "we believe that," "in our opinion") that add no information; background the reader already has; and process narration ("first we looked at X, then we considered Y") when only the conclusion of that process matters.
4. Convert paragraphs to lists where the content is genuinely parallel (a set of options, a set of risks); a list of five short items reads faster than one paragraph saying the same five things in prose.
5. Tighten individual sentences last: replace multi-word phrases with single words ("in order to" to "to", "due to the fact that" to "because"), and cut adjectives and adverbs that don't change the meaning.

Worked example
Before (47 words): "It is worth noting that, due to the fact that the vendor contract renewal date is rapidly approaching, we believe that it would probably be a good idea for us to schedule a review meeting sometime in the next two weeks in order to discuss next steps."

After (17 words): "The vendor contract renews soon. Let's schedule a review meeting within two weeks to decide next steps."

That's a 64% cut (47 words to 17) on this one sentence, achieved by removing three hedges ("it is worth noting," "we believe," "probably") and one restated phrase ("in order to" to "to"), not by removing any fact.

Trade-offs and pitfalls

• The risk in aggressive cutting is losing a caveat or edge case that genuinely mattered; after cutting, reread once specifically asking "did I just delete a risk or exception, not just a restatement?"
• Cutting to a target percentage (half the length) as a goal in itself can tempt you to remove real content once the easy hedges are gone; if you run out of filler before you hit the target, the document may have been genuinely that dense, and the honest move is to say so rather than cut substance to hit a number.
• Lists are faster to scan but can flatten genuine nuance between items; use them for parallel content, not for things that need qualification relative to each other.

Direct answer: LoRA (Low-Rank Adaptation) freezes the pretrained weight matrix and instead learns a small, low-rank update on top of it, so fine-tuning trains far fewer parameters than updating the full matrix while still adapting the model's behavior.

Structured elaboration: For a weight matrix $W$ of shape $(d_{out}, d_{in})$, LoRA replaces the usual full-matrix update with two much smaller trainable matrices $A$ (shape $r \times d_{in}$) and $B$ (shape $d_{out} \times r$), where the effective weight used at inference is:

$W' = W + \frac{\alpha}{r} \, B A$

Here $r \ll \min(d_{out}, d_{in})$ is the rank, a hyperparameter controlling how expressive the update can be (typical values are 4 to 64 for large language models). $\alpha$ is a scaling factor that controls the effective magnitude of the update relative to the rank; dividing by $r$ keeps the update's scale roughly comparable across different rank choices, so you can change $r$ without having to re-tune $\alpha$ from scratch. $B$ is typically initialized to all zeros and $A$ to small random values, so the adapted model starts out numerically identical to the original pretrained model and then diverges as training updates $A$ and $B$. LoRA adapters are most commonly applied to the attention query and value projection matrices (and sometimes the feed-forward layers), since those dominate a transformer's parameter count and strongly shape its behavior. Per-task adapters are stored as just the pair $(A, B)$ for each layer they are applied to, which is typically megabytes rather than the gigabytes a full fine-tuned checkpoint would need, so serving many task-specific variants of one base model becomes practical.

Worked example: For a single attention projection of shape $(12288, 12288)$ (a dimension similar to a large transformer's hidden size), full fine-tuning of that one projection would train $12288 \times 12288 = 150{,}994{,}944$ parameters. With LoRA at rank $r=8$, the trainable parameter count is $r \times (d_{in} + d_{out}) = 8 \times (12288 + 12288) = 196{,}608$ parameters, about $0.13\%$ of the full count, a roughly 768x reduction for that single projection. This is why LoRA cuts training memory so much: gradients and optimizer state (which for Adam-family optimizers are often 2-3x the raw parameter count) only need to be stored for $A$ and $B$, not for the frozen $12288 \times 12288$ matrix.

Trade-offs and pitfalls: LoRA reduces trainable parameters, but at inference the unmerged form ($W$ plus a separate low-rank multiply) adds a small amount of extra compute; in production this is almost always avoided by merging $BA$ into $W$ once training is done, which restores exactly the same inference cost as the original model with zero runtime overhead, at the cost of losing the ability to instantly swap adapters without reloading weights. Choosing $r$ too small can under-fit a task that genuinely needs a higher-rank update (complex domain shifts, multi-task mixtures), while choosing it unnecessarily large gives up most of LoRA's memory savings without a clear accuracy benefit, so rank is usually tuned empirically starting from a small value like 8.

Direct answer

Convert the condition into a 0/1 indicator (1 if $arr[i] \le k$, else 0), and notice the total count of 1s, call it $m$, never changes since swaps only move values around. The minimum swaps is $m$ minus the largest number of 1s already sitting inside any window of length $m$: slide a fixed-size window of length $m$ across the array once, track how many 1s are in it, and subtract the best count from $m$.

Structured elaboration

Why this reduces to a fixed-size sliding window:

1. Reduce the value condition to a binary property. Whether an element "counts" only depends on arr[i] <= k, so think of the array as a sequence of 1s (qualifying elements) and 0s (non-qualifying). The actual values stop mattering once you've made this reduction; only positions matter from here on.
2. The target size is fixed and known up front. If there are $m$ qualifying elements total, any valid final arrangement must place all $m$ of them into some contiguous block of length exactly $m$. You are choosing where that block ends up, not how many elements are in it.
3. Correctness of the swap count for one candidate window. Fix a candidate window of length $m$ and say it currently contains $x$ qualifying elements (so $m - x$ non-qualifying elements sit inside it). Since there are $m$ qualifying elements in total and $x$ of them are already inside, exactly $m - x$ qualifying elements sit outside the window. That gives a perfect one-to-one pairing: each non-qualifying element inside the window can be swapped directly with a qualifying element outside it, in exactly $m - x$ swaps, and no arrangement can do it in fewer (every one of those $m-x$ misplaced elements inside the window has to leave, and each swap moves at most one qualifying element in).

4. Minimize over all candidate windows. Since swaps required $= m - x$, minimizing swaps is the same as maximizing $x$, the count of qualifying elements already inside the window. Slide a window of fixed length $m$ across the array once (classic fixed-size sliding window: add the incoming element's contribution, drop the outgoing element's contribution), track the maximum $x$ seen, and the answer is $m - x_{\max}$.

Complexity: one pass to count $m$, one pass to slide the window: $O(n)$ time. The window count is maintained as a running integer, no auxiliary array is needed, so this runs in $O(1)$ extra space beyond the input.

Worked example

Using the array from the question: arr = [2, 7, 9, 5, 8, 7, 4], k = 5.

def min_swaps_to_group(arr, k):
    n = len(arr)
    total = sum(1 for x in arr if x <= k)
    if total == 0 or total == n:
        return 0
    window_count = sum(1 for x in arr[:total] if x <= k)
    best = window_count
    for i in range(total, n):
        if arr[i] <= k:
            window_count += 1
        if arr[i - total] <= k:
            window_count -= 1
        best = max(best, window_count)
    return total - best

arr = [2, 7, 9, 5, 8, 7, 4]
k = 5
print(f"arr={arr}, k={k}")
print(f"elements <= k: {[x for x in arr if x <= k]}")
result = min_swaps_to_group(arr, k)
print(f"min swaps = {result}")
assert result == 2

def min_swaps_auxiliary_array(arr, k):
    n = len(arr)
    indicator = [1 if x <= k else 0 for x in arr]
    total = sum(indicator)
    if total == 0 or total == n:
        return 0
    prefix = [0] * (n + 1)
    for i in range(n):
        prefix[i + 1] = prefix[i] + indicator[i]
    best = 0
    for i in range(n - total + 1):
        best = max(best, prefix[i + total] - prefix[i])
    return total - best

def brute_min_swaps(arr, k):
    n = len(arr)
    total = sum(1 for x in arr if x <= k)
    if total == 0 or total == n:
        return 0
    best = 0
    for i in range(n - total + 1):
        window = arr[i:i+total]
        cnt = sum(1 for x in window if x <= k)
        best = max(best, cnt)
    return total - best

import random
random.seed(5)
mismatches = 0
for _ in range(200):
    n = random.randint(1, 10)
    a = [random.randint(0, 10) for _ in range(n)]
    kk = random.randint(0, 10)
    r1, r2, r3 = min_swaps_to_group(a, kk), min_swaps_auxiliary_array(a, kk), brute_min_swaps(a, kk)
    if not (r1 == r2 == r3):
        mismatches += 1
print(f"200 randomized trials (seed 5): O(1)-space window, auxiliary-array, and brute force all agreed, mismatches={mismatches}")

Output:

arr=[2, 7, 9, 5, 8, 7, 4], k=5
elements <= k: [2, 5, 4]
min swaps = 2
200 randomized trials (seed 5): O(1)-space window, auxiliary-array, and brute force all agreed, mismatches=0

Trace: the qualifying indicator is [1,0,0,1,0,0,1], so $m = 3$. Every one of the five possible length-3 windows ([1,0,0], [0,0,1], [0,1,0], [1,0,0], [0,0,1]) contains exactly one qualifying element, so $x_{\max} = 1$ and the answer is $3 - 1 = 2$, matching the question's stated result. This was cross-checked against the brute-force reference and the auxiliary-array version shown above, over 200 randomized trials (seed 5); all three agreed in every trial, as the printed line confirms.

Trade-offs & pitfalls

• The "swap" here is a free swap between any two positions, not an adjacent swap. If the problem instead restricted swaps to adjacent elements only, the count would be a different (and generally larger) quantity related to counting inversions, not this window-based formula. Always confirm which swap model is meant before applying this technique.
• A common wrong turn is trying to simulate actual swaps rather than reasoning about a target window. The technique works precisely because you never need to decide an order of swaps: you only need to pick the best final window position, and the count follows algebraically.
• Watch the two boundary cases: if every element already qualifies ($m = n$) or none do ($m = 0$), the answer is trivially 0 and the sliding window should short-circuit rather than run (attempting a window of size 0 or size $n$ needs no scan).
• Keeping a running window count (add incoming, subtract outgoing) instead of re-summing the window from scratch each time is what keeps this $O(n)$ instead of $O(n \cdot m)$; re-summing per position is the most common efficiency regression candidates introduce under pressure.

Direct answer
When validation scores are close, the deciding factors are usually interpretability, inference latency and cost, training/maintenance complexity, and robustness to future data shifts, not the metric itself.

Structured elaboration
Logistic regression wins on interpretability (coefficients have a direct, explainable meaning), inference speed (a dot product versus a full forward pass), training simplicity, and often on robustness when the true relationship is close to linear or there isn't enough data to reliably fit a much more flexible model. A deep neural network wins if there's genuine, complex non-linear structure the data supports learning, if you expect to keep improving it with more data/features over time, or if it's part of a broader system (e.g. shared embeddings) that benefits from the same architecture family.
Beyond those two big axes: maintenance cost (a neural network typically needs more careful monitoring and retraining discipline), regulatory/compliance requirements (some domains effectively require an explainable model), and how the model will be consumed downstream (a real-time low-latency service favors the cheaper model).

Worked example
For a credit-approval decision where regulation requires explaining individual denials and a millisecond-level latency budget exists, logistic regression is very likely the right call even if the neural network scores half a point higher on validation AUC. For an internal ranking model with no explainability requirement and a generous latency budget, the marginal edge might justify the added complexity of the neural network.

Trade-offs & pitfalls
Don't let "the fancier model is probably better long-term" become the deciding factor by default; if the simpler model is genuinely competitive today, the burden of proof is on the more complex model to show it earns its added cost, not the other way around.