Airbnb Software Engineer (Mid-Level) Interview Preparation Guide

Direct answer. A shape-mismatch error tells you two tensors disagreed in dimension somewhere in the forward pass, but the traceback often points at the operation that FAILED, not the operation that introduced the wrong shape several layers earlier, so the debugging process is really about walking the shape forward from the input until it diverges from what you expect.

Step-by-step approach.

1. Print the input shape first, and compare it against what the first layer actually expects. A surprising number of shape bugs are simply "the input isn't shaped the way I assumed," not a bug in the model at all.
2. Use a model summary tool (or manually print .shape after each layer in a quick forward pass) to see the shape at every stage in one pass, rather than binary-searching by commenting out layers one at a time.
3. Add explicit shape assertions inside custom layers, at the point where a specific shape is assumed (assert x.shape[-1] == self.expected_dim, f"got {x.shape}"). This turns a downstream, confusing shape error into an immediate, precisely-located one the next time the bug is triggered, which pays for itself the first time someone else hits a variant of the same bug.
4. Write a small unit test with a known, fixed input shape that exercises just the suspect layer or block in isolation, rather than the whole model, so you can iterate on the fix without paying the cost of a full forward pass through everything else.

A concrete example of why step 1 matters. A very common real case: a model expects batch-first input (batch, seq_len, features) but receives (seq_len, batch, features) from a data loader or a different framework's convention. The shapes are individually valid tensors, nothing crashes until several layers in when a dimension that "coincidentally" matched for a while finally doesn't, at which point the error message points at a layer far from the true cause (the data loader).

The unit test that prevents recurrence. Something as small as:

def test_encoder_output_shape():
    x = torch.randn(4, 10, 32)  # (batch=4, seq_len=10, features=32), the CONTRACT this layer expects
    out = encoder(x)
    assert out.shape == (4, 10, 64), f"expected (4, 10, 64), got {out.shape}"

run in CI on every change to the layer or anything upstream of it, catches this class of bug the moment a shape contract is violated, rather than three deploys later when someone finally notices predictions look wrong.

Start by framing the problem: sorting files larger than RAM requires minimizing costly disk I/O. The standard solution is an external merge-sort augmented by parallelism, smart buffering, storage choice, and OS tuning.

External merge-sort strategy

• Phase 1 (run generation): Read chunks that fit in memory, sort in-memory, write sorted runs. Use multi-threaded in-memory sort (e.g., parallel quicksort) to utilize CPU while a single thread writes.
• Phase 2 (k-way merge): Merge multiple runs in a single pass using a k-way priority queue. Choose k so that input buffers for each run + output buffer fit in RAM to avoid extra I/O passes. If k is limited, do multi-pass merging.

Parallel I/O

• Overlap computation and I/O: use asynchronous I/O (AIO), prefetch reads while sorting previous chunk, and write runs in background threads.
• Striping across multiple disks (RAID0) or using multiple file descriptors can increase throughput; coordinate merges to read from different devices in parallel.
• For multi-core systems, dedicate threads for I/O vs CPU-bound work to avoid contention.

SSD vs HDD trade-offs

• SSD: much higher IOPS and lower latency, favors many small random reads during k-way merge and supports smaller buffer sizes. But watch for write amplification and endurance—use large sequential writes where possible.
• HDD: high sequential throughput but poor random IOPS. Favor larger, sequential reads/writes and reduce random seeks by increasing buffer sizes and merging runs to reduce passes.

Buffer sizing and layout

• Allocate per-run read buffers sized to amortize seek/latency: for HDDs prefer larger buffers (MBs); for SSDs smaller buffers (hundreds of KB) may be sufficient.
• Output buffer should be large enough to batch writes (tens of MB) to avoid small synchronous writes.
• Choose k = min(number_of_runs, floor((available_RAM - output_buf)/per_run_buf)). Larger k reduces merge passes but increases memory pressure and cache misses.

OS-level tuning

• I/O scheduler: on Linux use noop or deadline for SSDs to avoid unnecessary reordering; for HDDs deadline often helps; avoid cfq for high-throughput batch jobs.
• Read-ahead: increase readahead for HDDs to exploit sequential patterns; for SSDs reduce aggressive readahead to avoid wasting I/O.
• Filesystem: use ext4/xfs with large stripe and journal settings tuned for large files; consider direct I/O (O_DIRECT) to bypass page cache if you manage your own buffers to avoid double-caching.
• AIO and io_uring: prefer io_uring for high-performance async I/O on modern kernels.
• NUMA: pin threads and allocate buffers on local memory nodes to reduce cross-node latency.

Practical checklist

• Maximize sequential access when on HDD; exploit parallel random I/O on SSD.
• Overlap work and I/O with async pipelines.
• Size k and buffers to fit RAM and minimize passes.
• Test with realistic data sizes and use iostat, blktrace, perf, and fio to validate settings and identify hotspots.

This combination reduces disk waits, minimizes passes, and balances CPU, memory, and storage characteristics for efficient large-file sorting.

The idea in plain words

If the numbers add up to total, each of the k subsets must sum to target = total / k, so total must divide by k and no number may exceed target. After those quick checks, think of filling buckets one at a time: drop numbers into the current bucket until it holds exactly target, then open the next bucket. A bucket must never overflow. With at most 16 numbers, the set of numbers already placed fits in a 16-bit mask, so we can record which sets are reachable this way. The whole trick is that for a given set of placed numbers, how full the open bucket is follows from the set's sum: it is sum % target.

The DP, stated before any code

• State and meaning: ok[mask] is True when the numbers in mask can be placed, in some order, so that every bucket is exactly target except possibly the last, which is partly filled and not over target. Bit i of the mask stands for a[i], counting from 0. A cell is one subset of the items.
• Helper: sums[mask] is the sum of the items in mask. It is built from sums[mask without its lowest set bit] + a[index of that bit], where mask & -mask isolates the lowest set bit (in two's complement -mask flips all bits above the lowest set one; the next section shows it on a concrete mask).
• Recurrence: ok[mask | 1<<i] becomes True when ok[mask] is True, bit i is not in mask, and sums[mask] % target + a[i] <= target. The open bucket's fill is sums[mask] % target, and the new item must still fit in it.
• Base case: ok[0] = True (nothing placed).
• Fill order: increasing mask value. Adding a bit always gives a larger number, so each mask is final before it is used.
• Answer: ok[full], where full has every bit set. Because every full bucket holds exactly target and the total is k * target, this means exactly k buckets were completed.
• Preconditions checked first: total % k == 0 and max(a) <= target; an empty input returns False (there is nothing to put into k subsets). The items are positive integers as stated.

Complexity

• Time: building sums is O(2^n); the main loop tests at most n items for each of the 2^n masks, so O(n * 2^n). At n = 16 that is at most 65,536 * 16 = 1,048,576 item tests (the formula, an upper bound).
• Space: O(2^n) for ok and sums, 65,536 entries each at n = 16.

The lowest-set-bit trick, on a concrete mask

Two's complement is the way computers store negative integers: -x is the bit pattern of x with every bit flipped and then 1 added. Flipping turns the trailing zeros of x into ones and its lowest set bit into a zero; adding 1 carries through those ones, turns them back into zeros, and stops by setting that zero back to one. So -x matches x at the lowest set bit and below it, and is flipped above it, which is why mask & -mask keeps exactly that one bit. Python integers have no fixed width, so the program prints 8-bit views with & 255.

mask = 0b101100                                 # bits 2, 3 and 5 are set (bit 0 is the lowest bit)
width = 8                                       # show 8-bit patterns; Python ints are unbounded
def bits(x):
    return format(x & (2 ** width - 1), f"0{width}b")

print("mask          ", bits(mask), mask)
print("flip every bit", bits(~mask), "(this is -mask - 1)")
print("-mask         ", bits(-mask), "(flip every bit, then add 1)")
print("mask & -mask  ", bits(mask & -mask), mask & -mask, "-> only the lowest set bit survives")
print("bit_length - 1", (mask & -mask).bit_length() - 1, "-> index of that bit")
print("mask - 1      ", bits(mask - 1), "(the lowest set bit becomes 0, the zeros below it become 1)")
print("mask & (mask-1)", bits(mask & (mask - 1)), mask & (mask - 1), "-> the set without its lowest item")

Output (complete, unedited):

mask           00101100 44
flip every bit 11010011 (this is -mask - 1)
-mask          11010100 (flip every bit, then add 1)
mask & -mask   00000100 4 -> only the lowest set bit survives
bit_length - 1 2 -> index of that bit
mask - 1       00101011 (the lowest set bit becomes 0, the zeros below it become 1)
mask & (mask-1) 00101000 40 -> the set without its lowest item

The sums helper uses two of these lines: (mask & -mask).bit_length() - 1 is the index of the lowest item in the set, and mask & (mask - 1) is the set without it, whose sum was already computed because it is a smaller number.

Backtracking, with counted calls

Backtracking places the items one by one into any bucket where they still fit and undoes the choice on failure. In the worst case it tries k^n assignments. Two versions are shipped and counted, both returning the same answer as the DP on every instance: plain_backtrack skips only buckets that would overflow; pruned_backtrack places the largest items first and skips a bucket whose current sum equals one already tried for this item (two buckets with the same content are interchangeable). The run counts calls, the root call included, on instances where total divides by k and no partition exists (the case where backtracking cannot stop early), and prints the DP's 2^n masks and how many of them were reachable.

Code

import random
from itertools import product


def can_partition(a, k, descending=False, show=False, stats=None):
    """True if the positive integers in a split into k subsets with equal sums."""
    n, total = len(a), sum(a)
    if n == 0 or k < 1 or total % k:
        return False
    target = total // k
    if max(a) > target:
        return False
    size = 1 << n
    sums = [0] * size                              # sums[mask]: total of the items in mask
    for mask in range(1, size):
        low = (mask & -mask).bit_length() - 1
        sums[mask] = sums[mask & (mask - 1)] + a[low]
    ok = [False] * size                            # ok[mask]: mask packs into full buckets plus one partly filled bucket
    ok[0] = True
    for mask in (range(size - 1, -1, -1) if descending else range(size)):
        if not ok[mask]:
            continue
        fill = sums[mask] % target                 # how full the open bucket is
        if stats is not None:
            stats["reachable"] += 1
        for i in range(n):
            if not mask >> i & 1 and fill + a[i] <= target:
                ok[mask | 1 << i] = True
    if show:
        for mask in range(size):
            print(f"{mask:0{n}b}", f"{sums[mask]:3}", f"{sums[mask] % target:3}", "yes" if ok[mask] else "no")
    return ok[size - 1]


calls = {"plain": 0, "pruned": 0}


def plain_backtrack(a, k):
    """Put each item into any bucket it still fits in; no other pruning."""
    n, total = len(a), sum(a)
    if n == 0 or k < 1 or total % k:
        return False
    target, buckets = total // k, [0] * k

    def place(i):
        calls["plain"] += 1
        if i == n:
            return True
        for b in range(k):
            if buckets[b] + a[i] <= target:
                buckets[b] += a[i]
                if place(i + 1):
                    return True
                buckets[b] -= a[i]
        return False
    return place(0)


def pruned_backtrack(a, k):
    """Largest items first, and never try two buckets that currently hold the same sum."""
    n, total = len(a), sum(a)
    if n == 0 or k < 1 or total % k:
        return False
    target, buckets, items = total // k, [0] * k, sorted(a, reverse=True)

    def place(i):
        calls["pruned"] += 1
        if i == n:
            return True
        tried = set()
        for b in range(k):
            if buckets[b] + items[i] <= target and buckets[b] not in tried:
                tried.add(buckets[b])
                buckets[b] += items[i]
                if place(i + 1):
                    return True
                buckets[b] -= items[i]
        return False
    return place(0)


def exhaustive(a, k):
    """Reference: try every assignment of items to k labelled buckets."""
    n, total = len(a), sum(a)
    if n == 0 or k < 1 or total % k:
        return False
    for assign in product(range(k), repeat=n):
        sums = [0] * k
        for x, b in zip(a, assign):
            sums[b] += x
        if len(set(sums)) == 1:
            return True
    return False


# 1. The mask table for a small input
a, k = [3, 1, 2, 2, 2], 2
print("items", a, "k", k, "target", sum(a) // k)
print("mask(bit 4..0)  sum  open-bucket-fill  ok")
print("can partition:", can_partition(a, k, show=True))
print("masks from large to small gives:", can_partition(a, k, descending=True))

# 2. Counted calls on instances where the sum divides by k but no partition exists
print("n  k  plain calls  pruned calls  masks  reachable masks")
rng = random.Random(540)
rows = []
for n in (6, 8, 10, 12):
    while True:
        a = [rng.randint(1, 9) for _ in range(n)]
        k = 3
        if sum(a) % k == 0 and max(a) <= sum(a) // k and not pruned_backtrack(a, k):
            break
    calls["plain"] = calls["pruned"] = 0
    stats = {"reachable": 0}
    r1, r2, r3 = plain_backtrack(a, k), pruned_backtrack(a, k), can_partition(a, k, stats=stats)
    assert r1 == r2 == r3 == False
    print(n, k, "", calls["plain"], "", calls["pruned"], "", 1 << n, "", stats["reachable"], " items", a)
    rows.append((calls["plain"], 1 << n))
print("plain calls divided by masks:", " ".join(f"{c / mk:.1f}" for c, mk in rows))
print("growth per two more items, plain calls:", " ".join(f"x{rows[i + 1][0] / rows[i][0]:.1f}" for i in range(3)))
print("growth per two more items, masks:", " ".join(f"x{rows[i + 1][1] / rows[i][1]:.1f}" for i in range(3)))

# 3. The size limit in the question, 16 items
rng = random.Random(541)
while True:
    a = [rng.randint(1, 9) for _ in range(16)]
    k = 4
    if sum(a) % k == 0 and max(a) <= sum(a) // k:
        break
calls["pruned"] = 0
stats = {"reachable": 0}
print("n=16 items", a, "sum", sum(a), "target", sum(a) // k)
print("dp:", can_partition(a, k, stats=stats), "reachable masks", stats["reachable"], "of", 1 << 16,
      "| pruned backtracking:", pruned_backtrack(a, k), "calls", calls["pruned"])

# 4. Check against the exhaustive reference on 400 distinct cases (n = 0..7, k = 1..4, items 1..9)
seen, feasible = set(), 0
for a, k in [([], 1), ([5], 1), ([5], 2), ([1, 1], 2), ([1, 1], 3)]:
    seen.add((tuple(a), k))
    assert can_partition(a, k) == exhaustive(a, k) == plain_backtrack(a, k) == pruned_backtrack(a, k)
    feasible += can_partition(a, k)
rng = random.Random(54)
while len(seen) < 400:
    if rng.random() < 0.5:                                    # build a feasible case on purpose
        k, target, a = rng.randint(1, 3), rng.randint(1, 9), []
        for _ in range(k):
            left = target
            while left:
                x = rng.randint(1, left)
                a.append(x)
                left -= x
        if len(a) > 7:
            continue
        rng.shuffle(a)
    else:
        k = rng.randint(1, 4)
        a = [rng.randint(1, 9) for _ in range(rng.randint(0, 7))]
    key = (tuple(a), k)
    if key in seen:
        continue
    seen.add(key)
    want = exhaustive(a, k)
    assert can_partition(a, k) == want == plain_backtrack(a, k) == pruned_backtrack(a, k), key
    feasible += want
print("checked", len(seen), "distinct cases,", feasible, "feasible,", len(seen) - feasible, "infeasible")

Output (complete, unedited):

items [3, 1, 2, 2, 2] k 2 target 5
mask(bit 4..0)  sum  open-bucket-fill  ok
00000   0   0 yes
00001   3   3 yes
00010   1   1 yes
00011   4   4 yes
00100   2   2 yes
00101   5   0 yes
00110   3   3 yes
00111   6   1 yes
01000   2   2 yes
01001   5   0 yes
01010   3   3 yes
01011   6   1 yes
01100   4   4 yes
01101   7   2 yes
01110   5   0 yes
01111   8   3 yes
10000   2   2 yes
10001   5   0 yes
10010   3   3 yes
10011   6   1 yes
10100   4   4 yes
10101   7   2 yes
10110   5   0 yes
10111   8   3 yes
11000   4   4 yes
11001   7   2 yes
11010   5   0 yes
11011   8   3 yes
11100   6   1 no
11101   9   4 yes
11110   7   2 yes
11111  10   0 yes
can partition: True
masks from large to small gives: False
n  k  plain calls  pruned calls  masks  reachable masks
6 3  73  4  64  20  items [6, 1, 8, 6, 8, 7]
8 3  595  7  256  118  items [4, 8, 9, 4, 3, 7, 1, 9]
10 3  5515  43  1024  479  items [3, 8, 6, 4, 9, 3, 9, 9, 6, 9]
12 3  17215  410  4096  1944  items [3, 5, 4, 3, 9, 3, 3, 6, 9, 9, 3, 3]
plain calls divided by masks: 1.1 2.3 5.4 4.2
growth per two more items, plain calls: x8.2 x9.3 x3.1
growth per two more items, masks: x4.0 x4.0 x4.0
n=16 items [4, 9, 9, 2, 1, 4, 4, 8, 4, 9, 2, 8, 2, 6, 4, 8] sum 84 target 21
dp: True reachable masks 54253 of 65536 | pruned backtracking: True calls 2164
checked 400 distinct cases, 256 feasible, 144 infeasible

Worked trace and what the numbers say

For the items [3, 1, 2, 2, 2] with k = 2 the target is 5. The table lists the 32 subsets (bit 0 is the item 3, bit 4 is the last 2). The mask 00101 holds items 3 and 2, sums to 5, and so has an open-bucket fill of 0: one bucket is complete. The mask 11100 (the three 2s) is the only no: after two 2s the open bucket holds 4, and a third 2 would overflow the target of 5. The full mask 11111 is yes with fill 0, so a partition exists (3 + 2 and 1 + 2 + 2).

The comparison table makes three points. The plain backtracking calls (73, 595, 5515, 17215 for n = 6, 8, 10, 12) are 1.1, 2.3, 5.4, 4.2 times the number of 2^n masks (64, 256, 1024, 4096). Per two extra items the calls grow x8.2, x9.3, x3.1 while the masks grow x4.0, x4.0, x4.0, so on these four instances the calls are larger in absolute size than the table but do not outgrow it at every step; the worst-case bound k^n against 2^n is what separates them on adversarial inputs. With sorting and the equal-bucket skip the calls (4, 7, 43, 410) are far lower on these four seeded instances, so on instances like these well-pruned backtracking is competitive; four instances do not show how it behaves in general. The DP's advantage is its fixed bound: at n = 16 on the printed instance it examined 54,253 reachable masks, within the 65,536 possible, whatever the numbers look like (it never exceeds 2^n), whereas the backtracking bound is k^n. Pruned backtracking took 2,164 calls on that instance (a True case, where it can stop at the first solution).

Which to choose

In an interview the expected answer is the bitmask DP with its n * 2^n bound, compared with backtracking plus pruning. Exact bin packing variants and approaches for n around 30 are deeper material.

For n up to 16 with arbitrary values, commit to the bitmask DP: its running time is bounded by n * 2^n whatever the values. Use pruned backtracking when you expect many duplicates or an easy instance and want early exit; what would change the choice is a larger n (for much larger n the 2^n table no longer fits in memory) where pruned backtracking or a different formulation is the only option.

Edge cases and common mistakes

• total % k != 0, an item bigger than target, k larger than the number of items, and the empty input all return False before any table is built.
• k = 1 is True for any non-empty input. A single item is True only when k = 1.
• Filling masks in the wrong direction: the run shows the same table filled from large masks to small ones returning False for a partition that exists, because ok[0] is processed last and nothing propagates.
• The check compares the DP and both backtrackers with an exhaustive search over all k^n assignments on 400 distinct cases (n from 0 to 7, k from 1 to 4, items 1 to 9), including empty, single-item and infeasible cases, and the run prints how many were feasible.

Follow-ups

• Return the actual subsets: store which item set ok[mask], then walk back from the full mask and cut a new bucket whenever the running sum hits a multiple of target.
• Turn the boolean DP into dp[mask] = the minimum number of buckets, to solve bin packing exactly for small n.
• Items with duplicate values: sort and skip equal items in backtracking, or use counts as the state.

Running the code

python3 equal_subsets.py

Save the code block under "Code" as equal_subsets.py and the code block in the lowest-set-bit section as lowbit.py; run each with python3. Python 3.12, standard library only.

Direct answer

I shipped a change to a signup flow that looked correct in every test environment but broke for users on a specific combination of browser and network condition we hadn't covered, and it was a customer, not our monitoring, who found it first, mid-demo, which made the failure both technical and painfully visible. Working out why it failed meant separating the actual technical root cause from the process gap that let it ship at all, and the fix that stuck was the one that closed the process gap, not just the code.

What happened and how I investigated

The change passed our automated tests and looked fine in manual quality testing, but broke for a subset of users because of an interaction between a caching layer and a redirect that only showed up under a specific, uncommon network condition. It surfaced when a prospective customer hit it during a live demo, which told me something important on its own: our alerting wasn't watching for this failure mode at all, so if the customer hadn't hit it live, it could have persisted undetected. Rather than just fixing the immediate bug, I traced two separate things: the technical root cause, the caching and redirect interaction, and the process gap, which was that our test matrix didn't cover that network condition and our monitoring had no signal that would have caught it in production either.

What I said and to whom, while it was still broken

As soon as I confirmed the cause, I told my manager and the account team handling that customer directly, with the specific technical explanation and an honest estimate of the fix timeline, rather than a vague "we're looking into it." That let the account team manage the customer conversation with real information instead of a placeholder.

What changed as a result

The immediate fix addressed the caching and redirect bug. The change that outlived the incident was adding the specific network condition to our test matrix and adding a monitoring alert for that class of redirect failure, so the next similar bug would be caught by our own systems instead of by a customer mid-demo. I also flagged that our sign-off process treated "tests pass" as equivalent to "ready to ship" with no explicit check for untested conditions, which is a narrower and more honest description of what our tests actually covered.

Trade-offs and pitfalls

The pitfall is stopping at the technical fix and treating the incident as resolved, when the more durable failure was the process gap that let something with an untested condition ship in the first place. A failure caught by monitoring and one caught by a customer can share the identical root cause, but they are different signals about how much your detection is actually covering.

Direct answer. Pull the calculation into a function that takes its inputs and returns a value with no side effects, and push the side effect (the write) into a thin, separately-named function that does nothing else -- then the pure part is trivially unit-testable with no mocks at all.

Before

STORE = {}
def process(order_id, price, qty, discount_pct):
    total = price * qty
    total -= total * (discount_pct / 100)
    STORE[order_id] = total   # side effect buried inside "calculation"
    return total

Testing this requires a real or fake STORE even though the interesting logic is pure arithmetic.

After

def compute_total(price: float, qty: int, discount_pct: float) -> float:
    """Pure: same inputs always produce the same output, no I/O."""
    total = price * qty
    return total - total * (discount_pct / 100)

def persist_total(store: dict, order_id, total: float) -> None:
    """The only place that touches shared state."""
    store[order_id] = total

def process_after(store, order_id, price, qty, discount_pct) -> float:
    total = compute_total(price, qty, discount_pct)
    persist_total(store, order_id, total)
    return total

Verified: compute_total(100, 2, 10) == 180.0, and the full pipeline produces the identical 180.0 and identical stored value as the original.

What becomes easier to test

• compute_total needs zero setup: assert compute_total(100, 2, 10) == 180.0 is the entire test, no store, no mocking, no cleanup.
• You can now table-test dozens of price/qty/discount combinations cheaply, because none of them touch shared state.
• persist_total becomes small enough that its ONE test just confirms the dict got the right key/value -- you're not re-testing arithmetic every time you test persistence, and vice versa.
• Bugs get localized: if a total is wrong, the bug is in compute_total; if the wrong order_id was written, the bug is in persist_total. In the original, both possibilities are tangled in one function.

Trade-offs and pitfalls

• This split adds one more name and one more call in the composition function -- for a two-line function that's plausibly not worth it, but the moment you have edge cases (negative discounts, currency rounding, tiered discounts) the pure/impure split pays for itself immediately.
• Watch for a subtler version of the same bug: a function that LOOKS pure but secretly reads global mutable state (e.g., a discount rate from a global config) is not actually pure, and hides the same testability problem behind clean-looking code.
• Don't over-purify: a system needs side effects somewhere. The goal isn't zero side effects, it's ISOLATING them so the decision logic can be tested without them.

Direct answer

Decide by comparing the investment's expected payoff against its real cost, which is time and attention pulled from delivery, not just money, then bring your manager a specific, time-boxed ask paired with a coverage plan rather than an open-ended request.

Structured elaboration

• Name the investment type explicitly, since the shape of the ask differs: a certification (weigh its actual return on investment, or ROI, against the time and fee cost), a formal advanced degree (a far larger, multi-year time and money commitment for a credential), an internal on-the-job rotation (trades delivery time on your current team for exposure elsewhere), or simply protecting a fixed number of weekly hours split across growth domains.
• Compute the real cost honestly. If the ask is a fixed weekly-hours budget, name explicitly what shrinks to make room for it; a request that doesn't name its own trade-off reads as costless and gets challenged later.
• The negotiation lever that works is a bounded pilot: a defined number of weeks, a specific hours-per-week figure, a defined coverage plan for what you'd otherwise be doing, and a checkpoint partway through to reassess, rather than an open-ended protected-time request.
• If the ask involves protecting time against on-call or delivery pressure specifically, address it directly: name how coverage continues (pairing, documentation, swapping on-call windows) rather than letting the ask sound like a straight subtraction from the team's capacity.

Worked example

I wanted to protect a few hours a week for a structured certification relevant to where I wanted to grow, but I didn't just ask for the time. I brought my manager a specific ask: this many hours a week, for this many months, here's exactly what shrinks to make room for it, and here's how on-call coverage stays intact while I'm doing it. I framed it as a pilot with a checkpoint partway through: if my delivery velocity dropped noticeably, we'd pause and reassess rather than quietly abandoning either the study time or the delivery commitments. That framing made it an easy yes, because the cost was explicit and bounded instead of open-ended.

Trade-offs & pitfalls

• Asking for time without naming what shrinks to make room for it is the single biggest reason these requests get pushback.
• Treating a degree, a certification, an on-the-job rotation, and simply protected weekly hours as interchangeable asks misses that they carry very different costs and need different negotiations.
• Framing the investment purely as personal benefit rather than tying it to team or delivery value makes it harder to defend when priorities tighten.
• No checkpoint means no graceful way to pause if delivery genuinely suffers; always build in a reassessment point.

Direct answer

Waiting stops being the right call once the delay is on your critical path (the chain of work that directly determines your deadline) with no updated ETA, or once the cost of continuing to wait (rework, workarounds, compounding risk) is clearly larger than the cost of escalating. Decide the trigger in advance, not in the moment, and escalate by framing it around the shared deadline and offering to help unblock, not by assigning blame, so the relationship survives the conversation.

Structured elaboration

1. Set the trigger before you need it. At the point you first take on a dependency, agree on what "stalled" means and when you'll escalate if there's no movement, for example, "if there's no updated ETA by [date], I'll raise it." Deciding this ahead of time keeps the eventual call from being an emotionally loaded, in-the-moment judgment.
2. Watch for the signals that waiting has become the wrong call, even without a pre-set trigger: no visible progress or updated estimate, the delay has moved onto your own critical path, you're already absorbing compounding cost (rework, a growing workaround), or the nature of their blocker changed without anyone telling you.
3. Escalate at the right altitude, in order. Start with a direct conversation with the owner (not their manager first, which reads as going around them), then their lead if that doesn't move things, then a cross-functional or executive conversation only if the first two steps don't resolve it. Skipping straight to the top burns trust even when you're right to escalate.
4. Frame the escalation around the shared goal. Bring what you've tried and the concrete impact of the delay, and lead with an offer to help (extra hands, a clearer spec, a joint troubleshooting session) rather than a demand for status. This keeps the conversation collaborative instead of adversarial.
5. When the dependency is an external vendor rather than an internal team, the escalation lever is fundamentally different. There's no peer relationship conversation to have in the same sense: the path runs through contract renegotiation (invoking SLA, or service level agreement, terms, escalating through the vendor's account team) and executive/customer communication about timeline impact, because a vendor delay usually has stakeholders beyond your own working team (customers waiting on the date, your own leadership needing to manage expectations upward). The internal escalation ladder in step 3 assumes a peer relationship you can repair with tone and framing; the vendor case assumes a commercial relationship you manage with contract terms and proactive, honest communication about the schedule impact instead.

Worked example

Two weeks into waiting on an internal platform team's API, with no updated ETA since the first week and the launch date now two weeks out, the trigger from step 1 (no ETA update within a week) has already been crossed. The escalation opens with the owner directly: "This is now going to affect our launch date. What's actually blocking it, and is there anything I can do to help, pair on it, provide test data, take a piece of the work?" Only if that doesn't produce movement within a short, stated window does it go to their lead, framed the same way: shared deadline, concrete impact, an offer to help.

If instead the dependency were owned by an external vendor who'd gone quiet for two weeks on a contracted deliverable, the move isn't a peer conversation with an individual, it's raising the delay through the account relationship against the SLA in the contract, while separately and proactively telling internal leadership (and, if relevant, the customer waiting on the date) what the timeline impact now looks like, rather than continuing to absorb the delay silently and hoping the vendor resolves it before anyone notices.

Trade-offs & pitfalls

• Pitfall: escalating without a pre-agreed trigger, so the decision looks reactive or, worse, personal, when it happens.
• Pitfall: skipping escalation levels internally (going straight to a director) when a direct conversation with the owner hadn't been tried yet, damaging a relationship you'll need again.
• Pitfall: treating a vendor delay like an internal one, i.e., waiting patiently and being "collaborative" with a counterparty who has no equivalent incentive to preserve the relationship the way an internal peer does.
• Senior differentiator: pre-negotiating the escalation threshold when the dependency is first created, not two weeks into silence, and recognizing early which kind of dependency (peer relationship vs. commercial contract) you're actually managing, since that changes which lever you reach for.

Direct answer

Below is a script that reads git diff --numstat from STDIN (standard input, the default input stream a program reads from when data is piped into it) and emits one JSON object with total additions, total deletions, files changed, and any files whose additions exceed 200. Wiring it into continuous integration (CI, the automated build/test pipeline that runs on every push) means piping the pull request (PR)'s diff into the script and using its output to apply a label through the CI platform's API.

Structured elaboration

Approach

• git diff --numstat emits one tab-separated line per changed file: <added>\t<deleted>\t<filename>
• Binary files report - for added and deleted instead of a number, this must be handled explicitly rather than crashing the parser
• Parse each line, accumulate totals, and separately collect filenames whose additions exceed the 200-line threshold

Code

import sys
import json


def parse_numstat(lines):
    total_additions = 0
    total_deletions = 0
    files_changed = 0
    large_files = []
    for line in lines:
        line = line.rstrip("\n")
        if not line.strip():
            continue
        parts = line.split("\t")
        if len(parts) != 3:
            continue
        added_str, deleted_str, filename = parts
        files_changed += 1
        # binary files report '-' for added/deleted; treat as 0 rather than crash
        added = int(added_str) if added_str != "-" else 0
        deleted = int(deleted_str) if deleted_str != "-" else 0
        total_additions += added
        total_deletions += deleted
        if added > 200:
            large_files.append(filename)
    return {
        "total_additions": total_additions,
        "total_deletions": total_deletions,
        "files_changed": files_changed,
        "large_files": large_files,
    }


def main():
    lines = sys.stdin.readlines()
    result = parse_numstat(lines)
    print(json.dumps(result))


if __name__ == "__main__":
    main()

CI integration

• In CI, compute the numstat against the PR's actual merge base (for example git diff --numstat origin/main...HEAD, or the CI platform's own base-comparison ref) and pipe it into the script
• Parse the JSON output and use a non-empty large_files list, or total_additions crossing a team-chosen threshold, to apply a "large-pr" label through the CI platform's API (for example the GitHub CLI's gh pr edit --add-label, or a direct REST call)
• Run this as an early, cheap CI step, before slower checks, so the label is visible to reviewers as soon as the PR opens

Worked example

I ran this exact script against the following sample git diff --numstat input:

5	2	src/app.py
0	0	README.md
250	10	src/big_module.py
-	-	assets/logo.png

Piped through the script (... | python3 diffstats.py), the actual output was:

{"total_additions": 255, "total_deletions": 12, "files_changed": 4, "large_files": ["src/big_module.py"]}

That matches the arithmetic by hand: additions 5 + 0 + 250 + 0(binary) = 255, deletions 2 + 0 + 10 + 0(binary) = 12, four lines means four files changed, and only src/big_module.py has additions (250) over the 200 threshold.

Trade-offs and pitfalls

• numstat reports - for binary files; treating that as 0 additions is a deliberate choice so the parser doesn't crash, but it means a genuinely large binary change (a big generated asset) won't trip the large-file flag
• A pure line-count threshold doesn't capture every sense of "large": 250 lines of an auto-generated config file is not the same risk as 250 lines of hand-written logic; use this as a first-pass signal, not the only one
• Commits within the PR don't matter to this script, since it's comparing the merge base to the tip, which is usually what you want for a PR-level label
• If the base ref is stale (a local branch that hasn't been rebased), the numbers will be wrong; make sure CI diffs against the PR's true merge base, not a stale local reference

Direct answer

A grid is just a graph in disguise: each open cell is a node, and each cell is connected by an edge to its up-to-four open neighbors (up, down, left, right). Once that reframing is made, "shortest path on a grid" is the exact same problem as breadth-first search (BFS) shortest path on any unweighted graph, using the grid's implicit adjacency rule instead of an explicit adjacency list. Run BFS from start, and the moment goal is dequeued (or discovered), its recorded distance is the answer; return -1 if the queue empties first.

Structured elaboration

The only real design choices are how to represent "distance so far" and how to avoid materializing an explicit adjacency list (which would waste memory when the neighbor rule is a fixed, four-direction offset computable on the fly). The implementation below carries the running distance alongside each queued cell and validates bounds, blockage, and same-cell/blocked-goal cases up front.

Worked example

from collections import deque
from typing import List, Tuple

def shortest_grid_path(grid: List[List[int]], start: Tuple[int, int], goal: Tuple[int, int]) -> int:
    # 4-direction BFS shortest path length on a binary grid (0 = open, 1 =
    # blocked). Returns the number of steps (edges), or -1 if unreachable
    # or if start/goal is itself blocked.
    if not grid or not grid[0]:
        return -1
    R, C = len(grid), len(grid[0])
    sr, sc = start
    gr, gc = goal
    if not (0 <= sr < R and 0 <= sc < C and 0 <= gr < R and 0 <= gc < C):
        return -1
    if grid[sr][sc] == 1 or grid[gr][gc] == 1:
        return -1
    if start == goal:
        return 0

    visited = [[False] * C for _ in range(R)]
    visited[sr][sc] = True
    q = deque([(sr, sc, 0)])
    while q:
        r, c, d = q.popleft()
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < R and 0 <= nc < C and not visited[nr][nc] and grid[nr][nc] == 0:
                if (nr, nc) == (gr, gc):
                    return d + 1
                visited[nr][nc] = True
                q.append((nr, nc, d + 1))
    return -1

if __name__ == "__main__":
    grid = [
        [0, 0, 0, 0],
        [1, 1, 0, 1],
        [0, 0, 0, 0],
        [0, 1, 1, 0],
    ]
    print("start=(0,0) goal=(3,3):", shortest_grid_path(grid, (0, 0), (3, 3)))
    print("start=(0,0) goal=(1,0) [blocked goal]:", shortest_grid_path(grid, (0, 0), (1, 0)))
    print("start=(0,0) goal=(0,0) [same cell]:", shortest_grid_path(grid, (0, 0), (0, 0)))

    fully_blocked = [[0, 1], [1, 0]]
    print("no path around a wall:", shortest_grid_path(fully_blocked, (0, 0), (1, 1)))

    def full_bfs_dist(grid, start):
        R, C = len(grid), len(grid[0])
        dist = {start: 0}
        q = deque([start])
        while q:
            r, c = q.popleft()
            for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
                nr, nc = r+dr, c+dc
                if 0<=nr<R and 0<=nc<C and grid[nr][nc]==0 and (nr,nc) not in dist:
                    dist[(nr,nc)] = dist[(r,c)] + 1
                    q.append((nr,nc))
        return dist

    ref = full_bfs_dist(grid, (0,0))
    print("Matches independent full-BFS distance map:", ref.get((3,3)) == shortest_grid_path(grid, (0,0), (3,3)))

Output (actually executed with python3):

start=(0,0) goal=(3,3): 6
start=(0,0) goal=(1,0) [blocked goal]: -1
start=(0,0) goal=(0,0) [same cell]: 0
no path around a wall: -1
Matches independent full-BFS distance map: True

The full_bfs_dist helper independently computes the distance to every reachable open cell (not just the goal) and is cross-checked against the goal-seeking function's result for (3, 3), confirming both agree on the answer of 6 steps for that grid.

Complexity

Time $O(R \times C)$: each of the grid's cells is enqueued and dequeued at most once, and each dequeue does 4 constant-time neighbor checks. Space $O(R \times C)$ for the visited matrix and, in the worst case, the queue.

Edge cases

• Empty grid or empty row: not grid or not grid[0] catches both and returns -1 rather than raising on len(grid[0]).
• Start or goal out of bounds: validated explicitly before any traversal begins.
• Start or goal itself blocked: validated explicitly (a blocked cell cannot be a valid position to start or end at), rather than letting the BFS silently never enqueue it and return -1 for the wrong reason.
• start == goal: returns 0 directly, since this is a zero-edge path and would otherwise never get "discovered" by the neighbor-expansion loop (which only looks outward from the current cell, never re-examines the cell itself).

Trade-offs and pitfalls

• Common mistake: allowing 8-direction movement (including diagonals) when the problem specifies 4-direction, or vice versa; the neighbor offsets ((1,0),(-1,0),(0,1),(0,-1)) are the entire contract here, and getting this wrong silently produces a plausible-looking but incorrect shortest distance rather than an error.
• Common mistake: mutating the input grid in place to mark visited cells (for example, setting visited cells to 1) instead of using a separate visited matrix. This works for a single call but corrupts the caller's grid for any subsequent use, and fails outright if the caller expects to run multiple queries against the same grid.
• Optimization for very large grids: bidirectional BFS (searching outward from both start and goal simultaneously, stopping when the two frontiers meet) can substantially reduce the number of cells visited for grids where the shortest path is long relative to the grid's size, since two smaller expanding regions cover less total area than one large one before meeting. A commonly asked variant frames this as an m x n grid going corner to corner, which is simply the special case start=(0,0), goal=(R-1,C-1); nothing else about the algorithm changes.
• A as a further optimization:* for very large grids where most exploration is wasted moving away from the goal, A* with an admissible heuristic (Manhattan distance on a 4-direction grid) can prune the search space substantially versus plain BFS, at the cost of needing a priority queue and a heuristic function; this only pays off when the grid is large enough that the pruning outweighs the heap's constant-factor overhead.

Direct answer

Five metrics give a fast, honest read on a two-week sprint's health: sprint velocity, burndown rate, escaped defects, cycle time, and blocked days. Each one answers a different question (are we planning realistically, are we on pace day to day, is quality holding up, where is work actually getting stuck, and how much of our slowness is genuinely outside our control), so tracking all five together catches problems that any single metric would miss on its own.

Structured elaboration

Worked example

A team has averaged 32 points over its last 3 sprints. Late in the current 2-week sprint, only 21 points show as done on the burndown, with 2 working days left, a pace that would land well under the historical average if it holds. Cross-checking against blocked days shows 6 person-days lost that sprint to a shared staging environment being down for two separate days, the largest single contributor to the shortfall, and consistent with the same environment appearing as a blocker source in the two prior sprints too, which is exactly the kind of repeating pattern the blocked-days metric is meant to surface as a standing risk rather than sprint-by-sprint bad luck.

Trade-offs and pitfalls

The most common mistake is reacting to a single sprint's velocity dip as if it were a crisis, when a 3-sprint rolling average would show it's within normal variation. A second mistake is tracking these metrics without ever looking at them together: a team can look fine on velocity while escaped defects are quietly climbing, which velocity alone would never reveal. Watch also for treating cycle time and blocked days as the same thing; cycle time includes time genuinely spent working, while blocked days isolates time lost specifically to things outside the team's control, and conflating them hides which lever actually needs pulling.