# NVIDIA JR2020478 — Senior AI Agent Test Developer (SDET), Shanghai
## 3-day prep plan for Yi Gao (written Thu 2026-10-22, Beijing time)

| When (Beijing) | What |
|---|---|
| Fri Oct 23, Sat Oct 24, Sun Oct 25 | Core prep days (≈ 9–10 focused hours each) |
| Mon Oct 26 | Taper: ≤ 2 h practice + logistics dry-run at 14:00 |
| **Tue Oct 27, 14:00–15:35** | HackerRank coding test, 95 min, Chrome, VPN off, Python, **no AI** |
| **Tue Oct 27, 15:35** | Teams interview, ~50 min, camera on, screen-share ready. They will discuss your test solutions, technical skill, and experience |

> **The test ends at 15:35, and the interview starts at 15:35.** You have no buffer. Plan to finish the test by 15:28, and set up Teams before 14:00 (§4).

**The five things that matter most**
1. **Coding speed in plain Python, with no AI and no docs.** HackerRank flags tab-switching and leaving full-screen as malpractice, so you can't look up `datetime` formats mid-test. Appendix A has to be in your fingers.
2. **Partial credit.** Scoring is per hidden test case. Submit a working brute force early on every question, then optimize.
3. **Explaining your own code 0 minutes later.** Write readable code, and keep paper notes on approach, complexity and failures for each question (§4.5).
4. **Present Zeval / ztalk-mcp as test infrastructure for non-deterministic AI systems.** That is what the JD is asking for (§3.8).
5. **Be honest about the gaps and show you've started closing them.** Over the weekend you'll build *zeval-lite*: a pytest suite → GitHub Actions YAML → Docker image → Kubernetes Job on OrbStack. Afterwards you can say "I did this" rather than "I'd learn it" (Appendix C, T5).

Time split across Fri–Mon: **~17 h coding-test prep / ~11 h interview prep (≈ 60/40).** The test gates you, and the interview starts by discussing the test, so coding gets the larger share.

---

## 1. Predicted test composition

### 1.1 What is known (verified on HackerRank's candidate docs, 2026-10-22)
- **Scoring is per test case, with partial credit.** Each hidden test case passed earns its own points ([Evaluation method](https://candidatesupport.hackerrank.com/articles/4513323466-evaluation-method-of-coding-questions), [Hidden test cases](https://candidatesupport.hackerrank.com/articles/6052652546-hidden-test-cases)).
- **Python 3 = 3.14.2**, with a 10 s time limit and 512 MB memory. `requests`, `python-dateutil` and `pyyaml` are available. PyPy3 is only 3.6, so avoid it unless pure-loop code times out ([Execution environment](https://candidatesupport.hackerrank.com/articles/2201684846-execution-environment)).
- **Possible question types:** Coding, Multiple Choice, Database (SQL), DevOps (Linux VM), Code Review (inline comments on a diff), Subjective, QA projects (Selenium/Cypress/Playwright), and others ([Question types](https://candidatesupport.hackerrank.com/articles/9586502651-question-types-in-hackerrank)).
- **Malpractice includes** exiting full-screen, switching tabs, copying code from online sources, and outside help. Plagiarism detection catches renamed or reformatted copies ([Test integrity](https://candidatesupport.hackerrank.com/articles/9579706989-malpractices-in-tests)).
- **MCQs may use negative marking.** The instructions page will say so ([MCQ](https://candidatesupport.hackerrank.com/articles/3904571125-answer-multiple-choice-questions)).
- **Built-in AI Assistant:** HackerRank has one, but only the hiring company can enable it. If it's on, the onboarding says so and a panel appears. If there's no panel, it's off ([AI Assistant](https://candidatesupport.hackerrank.com/articles/7634558376-ai-assistant-in-tests)). **Plan for no AI.**
- **Submission at time-out:** after you edit a submitted answer, your last *submitted* version is what counts unless you re-run and re-submit ([Modifying submissions](https://candidatesupport.hackerrank.com/articles/5994519354-modifying-the-code-submissions-in-a-test), [Time-out evaluation](https://candidatesupport.hackerrank.com/articles/3576626591-evaluation-of-a-question-during-test-time-out)).
- **The editor is Monaco** (the VS Code engine). Its IntelliSense autocomplete is part of the platform and is fine to use ([Answer coding questions](https://candidatesupport.hackerrank.com/articles/9623161883-answer-coding-questions)).

### 1.2 Reasoning
- **The interview discusses your solutions, 0 minutes after the test.** So the test is mainly auto-scored *coding*. MCQs give an interviewer little to discuss. Expect at least 2 coding questions.
- **95 minutes** is consistent with either 3 coding questions of increasing difficulty, or 2 coding questions plus an MCQ/short-answer block.
- **The JD stresses Python/Linux/shell, test automation, flaky/regression analysis and log-heavy cloud systems.** So at least one question is likely a "realistic" data-processing task (logs, test results, events with timestamps) rather than pure puzzle DSA.
- **SDET online assessments at large tech companies** usually reuse standard library-style DSA (LeetCode Easy–Medium). They sometimes add testing-theory MCQs or a "find the bug / write tests" item.
- **QA web-UI projects (Selenium etc.) are unlikely.** The role is AI agents and cloud-native systems, not browser UI.

> The likelihoods below are **my estimates**, not leaked content. Prepare in proportion to them.

### 1.3 Most likely configurations
| Config | Estimate | Shape |
|---|---|---|
| **A** | ~50% | 3 coding: Q1 easy–medium practical (parsing/aggregation), Q2 medium DSA, Q3 medium(–hard) DSA or design-a-class |
| **B** | ~30% | 2 medium coding + 10–20 MCQs (Python semantics, testing theory, Linux, CI/containers/K8s) |
| **C** | ~20% | 2 coding + 1 non-standard item: fix-the-bug stub, "write test cases for X" (subjective), Code Review, REST API, or SQL |

### 1.4 Question types ranked by likelihood, with patterns and examples
| # | Type | Likelihood | Patterns to own | Example problems (links in §2) |
|---|---|---|---|---|
| 1 | **Algorithmic DSA (Python)** | ~95% (≥1 Q) | Hash-map counting · sliding window / two pointers · sort + greedy · stack / monotonic stack · heap / top-k · BFS / DFS on grid/graph · union-find · binary search (incl. on the answer) · intervals · prefix sums · light DP | Count Triplets, Frequency Queries, Fraudulent Activity Notifications, Roads and Libraries, LC 3, 56, 200, 207, 347, 560, 739, 875 |
| 2 | **Python practical / data processing** | ~70% | Parse lines → records (split/regex) · timestamps (`datetime`, tz offsets, windows) · group-by/aggregate (`Counter`/`defaultdict`) · multi-key sort with tie-breaks · exact output formatting · streaming/large input | Time Delta, Word Order, Company Logo, Time Conversion, LC 636 Exclusive Time, 937 Reorder Log Files, 811 Subdomain Visits, 1604 Key-Card Alert, 1169 Invalid Transactions; custom T1 flaky detector, T2 log triage |
| 3 | **Testing-flavored item** | ~40% | Fix a buggy function (mutable defaults, off-by-one, wrong comparator) · enumerate test cases / edge cases for a spec · implement a class to a spec, called by a hidden harness · review a diff · regression bisection | HR "Debugging": Default Arguments, Words Score; LC 8 atoi, 65 Valid Number, 468 Validate IP, 165 Compare Versions; LC 146 LRU, 1797 Auth Manager, 981; LC 278 First Bad Version |
| 4 | **MCQ block** | ~40% | Python gotchas · pytest/fixtures/exit codes · testing theory (BVA, equivalence classes, test pyramid, severity vs priority) · flaky causes · Linux pipelines/signals/permissions · Docker layers · K8s probes / OOMKilled · statistics of non-deterministic tests | Appendix B (16 Qs, used in the mock) |
| 5 | **REST API consumption** | ~20% | Paginated GET (`page`, `total_pages`), filter/aggregate, `requests` or `urllib` + `json`, money/strings parsing | jsonmock tasks T4-A…D (with answer keys) |
| 6 | **SQL** | ~15% | JOIN + GROUP BY + HAVING · window functions (ROW_NUMBER/RANK/DENSE_RANK) · self-join · date gaps · median | The Report, Top Competitors, SQL Project Planning, LC 176, 185, 180 |
| 7 | **Linux / DevOps VM or bash** | ~10% | grep/awk/sed/sort/uniq/cut pipelines · file ops · processes/ports | HR Shell: Cut #1, Sort #5, Uniq #2, Grep-A, Awk-1, Sed #3 |
| 8 | QA web project (Selenium/Playwright/Cypress) | <5% | — | **Skip.** |

**Difficulty to expect:** LeetCode Easy–Medium, sometimes a Medium-Hard with a naive solution that earns partial credit. Python TLE traps are common: O(n²) on n = 10⁵, `list.pop(0)`, deep recursion.

---

## 2. Practice map (all URLs curl-verified 2026-10-22; method in Appendix D)

**LeetCode note:** leetcode.com pages answer curl with a Cloudflare bot check (403), so each LeetCode problem was verified twice. First via LeetCode's own GraphQL API (exists, `isPaidOnly=false`). Second, the same slug on the CN mirror (200, real title). If leetcode.com is slow with VPN off, swap `leetcode.com` → `leetcode.cn` in any problem URL below; every slug was checked there too. **Premium problems I excluded:** Meeting Rooms II, Logger Rate Limiter, Design Hit Counter, Design Log Storage System, Analyze User Website Visit Pattern, Encode and Decode Strings.

### 2.1 Type 1 — Algorithmic DSA
**Where:**
- [HackerRank Interview Preparation Kit](https://www.hackerrank.com/interview/interview-preparation-kit). It uses the same editor and hidden-test scoring as the real test, so do most DSA reps here. Sections: [Dictionaries & Hashmaps](https://www.hackerrank.com/interview/interview-preparation-kit/dictionaries-hashmaps/challenges) · [Sorting](https://www.hackerrank.com/interview/interview-preparation-kit/sorting/challenges) · [String Manipulation](https://www.hackerrank.com/interview/interview-preparation-kit/strings/challenges) · [Greedy](https://www.hackerrank.com/interview/interview-preparation-kit/greedy-algorithms/challenges) · [Search](https://www.hackerrank.com/interview/interview-preparation-kit/search/challenges) · [Stacks & Queues](https://www.hackerrank.com/interview/interview-preparation-kit/stacks-queues/challenges) · [Graphs](https://www.hackerrank.com/interview/interview-preparation-kit/graphs/challenges) · [Arrays](https://www.hackerrank.com/interview/interview-preparation-kit/arrays/challenges) · [Dynamic Programming](https://www.hackerrank.com/interview/interview-preparation-kit/dynamic-programming/challenges)
- Real-test-UI rehearsal: [Problem Solving (Intermediate) certification](https://www.hackerrank.com/skills-verification/problem_solving_intermediate) or [Problem Solving (Basic)](https://www.hackerrank.com/skills-verification/problem_solving_basic). Each is 1 h 30 min with 2 questions, unseen problems, in the proctored test UI. Used on Sunday.
- LeetCode lists for extra reps (free): [Top Interview 150](https://leetcode.com/studyplan/top-interview-150/) · [LeetCode 75](https://leetcode.com/studyplan/leetcode-75/) · [Top 100 Liked](https://leetcode.com/studyplan/top-100-liked/) · [Grind 75](https://www.techinterviewhandbook.org/grind75/) · [NeetCode practice](https://neetcode.io/practice). CN mirrors: [面试经典 150](https://leetcode.cn/studyplan/top-interview-150/) · [LeetCode 75 (CN)](https://leetcode.cn/studyplan/leetcode-75/) · [热题 100](https://leetcode.cn/studyplan/top-100-liked/)

**Problems by pattern** (★ = in the 3-day plan; ◆ = reserved for the mock, so don't open it early):
| Pattern | HackerRank | LeetCode |
|---|---|---|
| Hash-map counting | ★[Ransom Note](https://www.hackerrank.com/challenges/ctci-ransom-note/problem) (E) · ★[Sherlock and Anagrams](https://www.hackerrank.com/challenges/sherlock-and-anagrams/problem) (M) · ★[Count Triplets](https://www.hackerrank.com/challenges/count-triplets-1/problem) (M) · ★[Frequency Queries](https://www.hackerrank.com/challenges/frequency-queries/problem) (M) · ★[Two Strings](https://www.hackerrank.com/challenges/two-strings/problem) (E) | [1 Two Sum](https://leetcode.com/problems/two-sum/) · [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/) · [128 Longest Consecutive](https://leetcode.com/problems/longest-consecutive-sequence/) · ★[347 Top K Frequent](https://leetcode.com/problems/top-k-frequent-elements/) · ★[560 Subarray Sum = K](https://leetcode.com/problems/subarray-sum-equals-k/) |
| Sliding window / two pointers | ◆[Fraudulent Activity Notifications](https://www.hackerrank.com/challenges/fraudulent-activity-notifications/problem) (M) · [Bear and Steady Gene](https://www.hackerrank.com/challenges/bear-and-steady-gene/problem) (M) | ★[3 Longest Substring w/o Repeat](https://leetcode.com/problems/longest-substring-without-repeating-characters/) · ★[438 Find All Anagrams](https://leetcode.com/problems/find-all-anagrams-in-a-string/) · [424 Char Replacement](https://leetcode.com/problems/longest-repeating-character-replacement/) · [15 3Sum](https://leetcode.com/problems/3sum/) · [11 Container With Most Water](https://leetcode.com/problems/container-with-most-water/) · [239 Sliding Window Max](https://leetcode.com/problems/sliding-window-maximum/) |
| Sort + greedy | [Max Min](https://www.hackerrank.com/challenges/angry-children/problem) (M) · [Luck Balance](https://www.hackerrank.com/challenges/luck-balance/problem) (E) · [Sorting: Comparator](https://www.hackerrank.com/challenges/ctci-comparator-sorting/problem) (M) · [Minimum Swaps 2](https://www.hackerrank.com/challenges/minimum-swaps-2/problem) (M) · [New Year Chaos](https://www.hackerrank.com/challenges/new-year-chaos/problem) (M) | [621 Task Scheduler](https://leetcode.com/problems/task-scheduler/) · [452 Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/) |
| Intervals | [Gridland Metro](https://www.hackerrank.com/challenges/gridland-metro/problem) (M) | ★[56 Merge Intervals](https://leetcode.com/problems/merge-intervals/) · [57 Insert Interval](https://leetcode.com/problems/insert-interval/) · ★[435 Non-overlapping](https://leetcode.com/problems/non-overlapping-intervals/) · [986 Interval Intersections](https://leetcode.com/problems/interval-list-intersections/) · [1094 Car Pooling](https://leetcode.com/problems/car-pooling/) |
| Stack / monotonic stack | ★[Balanced Brackets](https://www.hackerrank.com/challenges/balanced-brackets/problem) (M) · [Largest Rectangle](https://www.hackerrank.com/challenges/largest-rectangle/problem) (M) · [Queues: A Tale of Two Stacks](https://www.hackerrank.com/challenges/ctci-queue-using-two-stacks/problem) (M) | [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/) · ★[155 Min Stack](https://leetcode.com/problems/min-stack/) · ★[739 Daily Temperatures](https://leetcode.com/problems/daily-temperatures/) · [150 Eval RPN](https://leetcode.com/problems/evaluate-reverse-polish-notation/) · ★[394 Decode String](https://leetcode.com/problems/decode-string/) |
| Heap / top-k / streaming | ★[Jesse and Cookies](https://www.hackerrank.com/challenges/jesse-and-cookies/problem) (E) · [QHEAP1](https://www.hackerrank.com/challenges/qheap1/problem) (E) · ★[Find the Running Median](https://www.hackerrank.com/challenges/find-the-running-median/problem) (H) | ★[215 Kth Largest](https://leetcode.com/problems/kth-largest-element-in-an-array/) · [295 Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/) · [692 Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/) · [23 Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/) (merge logs by timestamp) · [1834 Single-Threaded CPU](https://leetcode.com/problems/single-threaded-cpu/) · [1882 Process Tasks Using Servers](https://leetcode.com/problems/process-tasks-using-servers/) |
| BFS / DFS / grid | [Castle on the Grid](https://www.hackerrank.com/challenges/castle-on-the-grid/problem) (M) · [DFS: Connected Cell](https://www.hackerrank.com/challenges/ctci-connected-cell-in-a-grid/problem) · [BFS: Shortest Reach](https://www.hackerrank.com/challenges/ctci-bfs-shortest-reach/problem) · [Find the nearest clone](https://www.hackerrank.com/challenges/find-the-nearest-clone/problem) (M) | ★[200 Number of Islands](https://leetcode.com/problems/number-of-islands/) · ★[994 Rotting Oranges](https://leetcode.com/problems/rotting-oranges/) · [133 Clone Graph](https://leetcode.com/problems/clone-graph/) · [79 Word Search](https://leetcode.com/problems/word-search/) |
| Components / union-find | ◆[Roads and Libraries](https://www.hackerrank.com/challenges/torque-and-development/problem) (M) · ★[Components in a graph](https://www.hackerrank.com/challenges/components-in-graph/problem) (M) · [Journey to the Moon](https://www.hackerrank.com/challenges/journey-to-the-moon/problem) (M) | [547 Number of Provinces](https://leetcode.com/problems/number-of-provinces/) · [684 Redundant Connection](https://leetcode.com/problems/redundant-connection/) · [721 Accounts Merge](https://leetcode.com/problems/accounts-merge/) |
| Topo sort / shortest path | — | ★[207 Course Schedule](https://leetcode.com/problems/course-schedule/) (test/build dependency order) · [210 Course Schedule II](https://leetcode.com/problems/course-schedule-ii/) · ★[743 Network Delay Time](https://leetcode.com/problems/network-delay-time/) |
| Binary search | [Pairs](https://www.hackerrank.com/challenges/pairs/problem) (M) · [Minimum Time Required](https://www.hackerrank.com/challenges/minimum-time-required/problem) (M) · [Ice Cream Parlor](https://www.hackerrank.com/challenges/ctci-ice-cream-parlor/problem) (M) | ★[278 First Bad Version](https://leetcode.com/problems/first-bad-version/) (= git bisect) · ★[875 Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas/) · [34 First/Last Position](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/) · [33 Rotated Array](https://leetcode.com/problems/search-in-rotated-sorted-array/) |
| Prefix sum / difference array | [Array Manipulation](https://www.hackerrank.com/challenges/crush/problem) (H) | [238 Product Except Self](https://leetcode.com/problems/product-of-array-except-self/) |
| DP (low priority for this role) | [Max Array Sum](https://www.hackerrank.com/challenges/max-array-sum/problem) (M) · [Abbreviation](https://www.hackerrank.com/challenges/abbr/problem) (M) | [70](https://leetcode.com/problems/climbing-stairs/) · [198](https://leetcode.com/problems/house-robber/) · [322](https://leetcode.com/problems/coin-change/) · [300](https://leetcode.com/problems/longest-increasing-subsequence/) · [1143](https://leetcode.com/problems/longest-common-subsequence/) · [139](https://leetcode.com/problems/word-break/) |

### 2.2 Type 2 — Python practical / data processing
**Where:** the [HackerRank Python domain](https://www.hackerrank.com/domains/python). Target the subdomains Collections, Date and Time, Regex and Parsing, Errors and Exceptions, Built-Ins, and Debugging. Python docs to memorize from *before* Tuesday: [collections](https://docs.python.org/3/library/collections.html) · [datetime](https://docs.python.org/3/library/datetime.html) · [re](https://docs.python.org/3/library/re.html) · [itertools](https://docs.python.org/3/library/itertools.html) · [heapq](https://docs.python.org/3/library/heapq.html) · [bisect](https://docs.python.org/3/library/bisect.html) · [functools](https://docs.python.org/3/library/functools.html) · [Time complexity of builtins](https://wiki.python.org/python/language/TimeComplexity.html)

| Pattern | HackerRank | LeetCode |
|---|---|---|
| Counting + exact output | ★[Word Order](https://www.hackerrank.com/challenges/word-order/problem) (M) · ★[Company Logo](https://www.hackerrank.com/challenges/most-commons/problem) (M) · [collections.Counter()](https://www.hackerrank.com/challenges/collections-counter/problem) · [DefaultDict Tutorial](https://www.hackerrank.com/challenges/defaultdict-tutorial/problem) · [Collections.OrderedDict()](https://www.hackerrank.com/challenges/py-collections-ordereddict/problem) · [Collections.namedtuple()](https://www.hackerrank.com/challenges/py-collections-namedtuple/problem) · [Compress the String!](https://www.hackerrank.com/challenges/compress-the-string/problem) (groupby) | ★[811 Subdomain Visit Count](https://leetcode.com/problems/subdomain-visit-count/) · [609 Find Duplicate File](https://leetcode.com/problems/find-duplicate-file-in-system/) |
| Custom sort keys | [Athlete Sort](https://www.hackerrank.com/challenges/python-sort-sort/problem) · [ginortS](https://www.hackerrank.com/challenges/ginorts/problem) | ★[937 Reorder Data in Log Files](https://leetcode.com/problems/reorder-data-in-log-files/) |
| Time / timestamps | ◆[Time Delta](https://www.hackerrank.com/challenges/python-time-delta/problem) (M) · ★[Time Conversion](https://www.hackerrank.com/challenges/time-conversion/problem) (E) · [The Time in Words](https://www.hackerrank.com/challenges/the-time-in-words/problem) (M) · [Library Fine](https://www.hackerrank.com/challenges/library-fine/problem) (E) · [Calendar Module](https://www.hackerrank.com/challenges/calendar-module/problem) | ★[1604 Key-Card Alert (1-hour window)](https://leetcode.com/problems/alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/) · [1169 Invalid Transactions](https://leetcode.com/problems/invalid-transactions/) · [1348 Tweet Counts per Frequency](https://leetcode.com/problems/tweet-counts-per-frequency/) · [981 Time-Based KV Store](https://leetcode.com/problems/time-based-key-value-store/) |
| Event logs → state | ★[Simple Text Editor](https://www.hackerrank.com/challenges/simple-text-editor/problem) (M, ops + undo) | ★[636 Exclusive Time of Functions](https://leetcode.com/problems/exclusive-time-of-functions/) · [1396 Design Underground System](https://leetcode.com/problems/design-underground-system/) · [71 Simplify Path](https://leetcode.com/problems/simplify-path/) |
| Regex / validation | [Re.findall() & Re.finditer()](https://www.hackerrank.com/challenges/re-findall-re-finditer/problem) · [Group(), Groups() & Groupdict()](https://www.hackerrank.com/challenges/re-group-groups/problem) · [Regex Substitution](https://www.hackerrank.com/challenges/re-sub-regex-substitution/problem) · [Re.split()](https://www.hackerrank.com/challenges/re-split/problem) · [Validating UID](https://www.hackerrank.com/challenges/validating-uid/problem) · [Validating Credit Card Numbers](https://www.hackerrank.com/challenges/validating-credit-card-number/problem) · [Validating and Parsing Email Addresses](https://www.hackerrank.com/challenges/validating-named-email-addresses/problem) · [Detect HTML Tags…](https://www.hackerrank.com/challenges/detect-html-tags-attributes-and-attribute-values/problem) · [Matrix Script](https://www.hackerrank.com/challenges/matrix-script/problem) (H) · [Strong Password](https://www.hackerrank.com/challenges/strong-password/problem) (E) | [468 Validate IP Address](https://leetcode.com/problems/validate-ip-address/) · [165 Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/) · [8 atoi](https://leetcode.com/problems/string-to-integer-atoi/) · [443 String Compression](https://leetcode.com/problems/string-compression/) · [68 Text Justification](https://leetcode.com/problems/text-justification/) (stretch) |
| Exceptions / parsing robustness | [Exceptions](https://www.hackerrank.com/challenges/exceptions/problem) · [Incorrect Regex](https://www.hackerrank.com/challenges/incorrect-regex/problem) · [XML2 - Max Depth](https://www.hackerrank.com/challenges/xml2-find-the-maximum-depth/problem) | — |
| SDET-flavored originals | Appendix C: **T1** flaky & regression detector, **T2** log triage (both have verified sample I/O) | — |

### 2.3 Type 3 — Testing-flavored items
| Sub-type | Practice |
|---|---|
| Fix-the-bug (stub with defects) | HR Python "Debugging": ★[Default Arguments](https://www.hackerrank.com/challenges/default-arguments/problem) (M), ★[Words Score](https://www.hackerrank.com/challenges/words-score/problem) (M). Also Appendix A2 gotchas, which are the usual planted bugs |
| Enumerate test cases first, then code | Write 8–10 cases *before* coding: [8 atoi](https://leetcode.com/problems/string-to-integer-atoi/) · [65 Valid Number](https://leetcode.com/problems/valid-number/) · [468 Validate IP](https://leetcode.com/problems/validate-ip-address/) · [165 Compare Versions](https://leetcode.com/problems/compare-version-numbers/) · [Time Conversion](https://www.hackerrank.com/challenges/time-conversion/problem). Use the EBIDPP checklist (§4.5) |
| Implement a class to a spec | ★[146 LRU Cache](https://leetcode.com/problems/lru-cache/) · ★[1797 Design Authentication Manager](https://leetcode.com/problems/design-authentication-manager/) (TTL) · ★[981 Time-Based KV](https://leetcode.com/problems/time-based-key-value-store/) · [1146 Snapshot Array](https://leetcode.com/problems/snapshot-array/) · [1472 Browser History](https://leetcode.com/problems/design-browser-history/) · [2034 Stock Price Fluctuation](https://leetcode.com/problems/stock-price-fluctuation/) · [2349 Number Container System](https://leetcode.com/problems/design-a-number-container-system/) · [729 My Calendar I](https://leetcode.com/problems/my-calendar-i/) · [341 Flatten Nested List Iterator](https://leetcode.com/problems/flatten-nested-list-iterator/) |
| Regression bisection | ★[278 First Bad Version](https://leetcode.com/problems/first-bad-version/) + [git bisect](https://git-scm.com/docs/git-bisect) |
| Write pytest tests | Appendix C **T3** (retry/backoff + tests) and **T5** (zeval-lite). Docs: [fixtures](https://docs.pytest.org/en/stable/how-to/fixtures.html) · [parametrize](https://docs.pytest.org/en/stable/how-to/parametrize.html) · [monkeypatch](https://docs.pytest.org/en/stable/how-to/monkeypatch.html) |

### 2.4 Type 4 — MCQ
Appendix B (16 questions, part of the mock) plus the Appendix A2/A3 cheat sheets. Depth sources are in §3.10 (G1–G8).

### 2.5 Type 5 — REST API consumption
- **Live mock endpoints** (HackerRank's real test fixtures): [football_matches](https://jsonmock.hackerrank.com/api/football_matches?year=2011&team1=Barcelona&page=1) · [articles](https://jsonmock.hackerrank.com/api/articles?page=1) · [iot_devices](https://jsonmock.hackerrank.com/api/iot_devices/search?status=RUNNING&page=1) · [transactions](https://jsonmock.hackerrank.com/api/transactions?page=1). The tasks and answer keys are in Appendix C, **T4**.
- Library docs: [urllib.request](https://docs.python.org/3/library/urllib.request.html) · [requests](https://requests.readthedocs.io/en/latest/)
- [REST API (Intermediate) certification](https://www.hackerrank.com/skills-verification/rest_api_intermediate): 1 h 30 min, 2 questions, and **you get one attempt only**. Don't spend it as practice before Tuesday.

### 2.6 Type 6 — SQL (low priority)
- [HackerRank SQL domain](https://www.hackerrank.com/domains/sql): [The Report](https://www.hackerrank.com/challenges/the-report/problem) · [Top Competitors](https://www.hackerrank.com/challenges/full-score/problem) · [Challenges](https://www.hackerrank.com/challenges/challenges/problem) · [Contest Leaderboard](https://www.hackerrank.com/challenges/contest-leaderboard/problem) · [SQL Project Planning](https://www.hackerrank.com/challenges/sql-projects/problem) · [Placements](https://www.hackerrank.com/challenges/placements/problem) · [Symmetric Pairs](https://www.hackerrank.com/challenges/symmetric-pairs/problem) · [Occupations](https://www.hackerrank.com/challenges/occupations/problem) · [Binary Tree Nodes](https://www.hackerrank.com/challenges/binary-search-tree-1/problem) · [Weather Observation Station 20](https://www.hackerrank.com/challenges/weather-observation-station-20/problem) (median)
- LeetCode [SQL 50](https://leetcode.com/studyplan/top-sql-50/) (CN: [高频 SQL 50](https://leetcode.cn/studyplan/sql-free-50/)). Specific problems: [176](https://leetcode.com/problems/second-highest-salary/) · [178](https://leetcode.com/problems/rank-scores/) · [180](https://leetcode.com/problems/consecutive-numbers/) · [184](https://leetcode.com/problems/department-highest-salary/) · [185](https://leetcode.com/problems/department-top-three-salaries/) · [197](https://leetcode.com/problems/rising-temperature/) · [550](https://leetcode.com/problems/game-play-analysis-iv/)
- Cheap rehearsal: [SQL (Basic) certification](https://www.hackerrank.com/skills-verification/sql_basic) (30 min, 2 questions)

### 2.7 Type 7 — Linux shell
[HackerRank Linux Shell domain](https://www.hackerrank.com/domains/shell): ★[Cut #1](https://www.hackerrank.com/challenges/text-processing-cut-1/problem) · ★[Sort Command #5](https://www.hackerrank.com/challenges/text-processing-sort-5/problem) · ★['Uniq' Command #2](https://www.hackerrank.com/challenges/text-processing-in-linux-the-uniq-command-2/problem) · ★['Grep' - A](https://www.hackerrank.com/challenges/text-processing-in-linux-the-grep-command-4/problem) · ★['Awk' - 1](https://www.hackerrank.com/challenges/awk-1/problem) · ★['Sed' command #3](https://www.hackerrank.com/challenges/text-processing-in-linux-the-sed-command-3/problem) · ['Grep' #1](https://www.hackerrank.com/challenges/text-processing-in-linux-the-grep-command-1/problem) · ['Awk' - 2](https://www.hackerrank.com/challenges/awk-2/problem) · [Paste - 1](https://www.hackerrank.com/challenges/paste-1/problem) · ['Tr' Command #1](https://www.hackerrank.com/challenges/text-processing-tr-1/problem) · [Compute the Average](https://www.hackerrank.com/challenges/bash-tutorials---compute-the-average/problem) · [Tail #2](https://www.hackerrank.com/challenges/text-processing-tail-2/problem). One-liners are in Appendix A3.

---

## 3. The 3-day plan

### 3.0 Rules for all four days
- **No AI autocomplete while practicing.** Turn off Copilot, Codex, Claude, Cursor Tab, etc. in your editor until Tuesday evening, because you need the muscle memory back.
- **Time caps:** Easy 10–12 min, Medium 20–25 min. When you hit the cap, read the HackerRank Discussions tab or a hint. Then **close it and re-implement from a blank editor**, and log it in `errors.md`.
- **Every problem follows one ritual:** constraints → target complexity → 3 edge cases written down → code → run → submit. You will use exactly this ritual on Tuesday.
- **`errors.md`** has one line per lost point: `problem | label (K/I/B/E/T/F/M/R, see §3.5) | rule I'll apply next time`.
- **Hard stop 21:30 each night.** Sleep is worth more than a 10th problem.
- **If Friday is a working day:** do D1-1 before work and D1-2 + D1-3 in the evening (≈ 4.5 h). Move D1-4 (S1–S3) to Sunday 19:00–20:30 in place of D3-6. Do D1-5 (pytest + Lab step 1) in Saturday's D2-7 slot, and move D2-7 (MCQ/Linux) to Monday 09:30–10:30 in place of the re-solves. From Set B keep only Balanced Brackets and LC 739 (do them Saturday 08:30 with the warm-up).

### 3.1 Tonight, Thu Oct 22 (30–45 min)
- [ ] In Chrome, log in or create your HackerRank account (use your application email). Solve [Sales by Match](https://www.hackerrank.com/challenges/sock-merchant/problem) to get a feel for the editor: Run vs Submit, custom input, debug output.
- [ ] Set up a local env. pytest isn't installed for your system `python3` (3.14.7), so: `python3 -m venv ~/nvprep/.venv && source ~/nvprep/.venv/bin/activate && pip install pytest pytest-xdist pytest-randomly pytest-rerunfailures pytest-timeout pytest-cov hypothesis requests`
- [ ] Disable AI completion in your editor.
- [ ] Create `~/nvprep/errors.md` and `~/nvprep/stories.md`.
- [ ] In `stories.md`, fill in the **[fill]** numbers for S1–S10 (§3.8) from memory or your notes: case counts, agreement rates, latencies, regressions caught. **Never use confidential Ztalk data in anything you show.**

### 3.2 Day 1 — Fri Oct 23: re-warm the hands, start the bridge
| Time | Track | Block |
|---|---|---|
| 08:30–09:00 | Code | **D1-1 Stdlib recall.** Type Appendix A1 from memory into a blank file, diff it against the appendix, and retype what you missed |
| 09:00–11:45 | Code | **D1-2 DSA Set A: hashing / windows / sort** (list below) |
| 11:45–12:45 | — | Lunch + walk |
| 12:45–14:45 | Code | **D1-3 Practical Set P: logs, strings, time** (list below) |
| 15:00–16:30 | Interview | **D1-4 Resume deep-dive I.** Write story cards S1–S3 (§3.8) in `stories.md`. Say each aloud in 2 minutes, record once, listen once, cut the filler |
| 16:45–18:30 | Interview (gap) | **D1-5 G1 pytest crash.** 45 min on the docs (fixtures, parametrize, marks, monkeypatch, tmp_path), then zeval-lite **Lab step 1** (Appendix C, T5) |
| 18:30–19:30 | — | Dinner |
| 19:30–21:00 | Code | **D1-6 DSA Set B: stacks / queues / heaps** (list below) |
| 21:00–21:30 | Both | Update `errors.md`. Read §3.4 *rules* only; don't open the mock problems |

**Set A** (20-min cap each): [Ransom Note](https://www.hackerrank.com/challenges/ctci-ransom-note/problem) (10 min) → [Sherlock and Anagrams](https://www.hackerrank.com/challenges/sherlock-and-anagrams/problem) → [Count Triplets](https://www.hackerrank.com/challenges/count-triplets-1/problem) → [Frequency Queries](https://www.hackerrank.com/challenges/frequency-queries/problem) (watch I/O speed) → [LC 3](https://leetcode.com/problems/longest-substring-without-repeating-characters/) → [LC 438](https://leetcode.com/problems/find-all-anagrams-in-a-string/) → [LC 347](https://leetcode.com/problems/top-k-frequent-elements/) → [LC 560](https://leetcode.com/problems/subarray-sum-equals-k/) → [LC 56](https://leetcode.com/problems/merge-intervals/). Stretch: [LC 15](https://leetcode.com/problems/3sum/), [Sherlock and the Valid String](https://www.hackerrank.com/challenges/sherlock-and-valid-string/problem).

**Set P:** [Word Order](https://www.hackerrank.com/challenges/word-order/problem) → [Company Logo](https://www.hackerrank.com/challenges/most-commons/problem) (tie-break!) → [Time Conversion](https://www.hackerrank.com/challenges/time-conversion/problem) (12AM/12PM) → [LC 937](https://leetcode.com/problems/reorder-data-in-log-files/) → [LC 811](https://leetcode.com/problems/subdomain-visit-count/) → [LC 636](https://leetcode.com/problems/exclusive-time-of-functions/) → [LC 1604](https://leetcode.com/problems/alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/) → **T1** flaky detector (Appendix C, 30 min). Stretch: [LC 1169](https://leetcode.com/problems/invalid-transactions/).

**Set B:** [Balanced Brackets](https://www.hackerrank.com/challenges/balanced-brackets/problem) (10 min) → [LC 155](https://leetcode.com/problems/min-stack/) → [LC 739](https://leetcode.com/problems/daily-temperatures/) → [LC 394](https://leetcode.com/problems/decode-string/) → [Jesse and Cookies](https://www.hackerrank.com/challenges/jesse-and-cookies/problem) → [LC 215](https://leetcode.com/problems/kth-largest-element-in-an-array/) → [Find the Running Median](https://www.hackerrank.com/challenges/find-the-running-median/problem). Stretch: [LC 150](https://leetcode.com/problems/evaluate-reverse-polish-notation/).

### 3.3 Day 2 — Sat Oct 24: the mock, then breadth
| Time | Track | Block |
|---|---|---|
| 08:30–09:00 | Code | **D2-1** Warm-up: [Two Strings](https://www.hackerrank.com/challenges/two-strings/problem), [Alternating Characters](https://www.hackerrank.com/challenges/alternating-characters/problem) (≤ 15 min total). Type the A1 templates once |
| **09:00–10:35** | Code | **D2-2 FULL 95-MIN MOCK** (§3.4) |
| 10:35–10:50 | — | Break: walk, no screens |
| 10:50–12:20 | Code | **D2-3 Same-day review** (§3.5) |
| 12:20–13:20 | — | Lunch |
| 13:20–15:20 | Code | **D2-4 DSA Set C: graphs / binary search / intervals.** Start with whichever pattern the review flagged as worst |
| 15:35–17:05 | Interview | **D2-5 Resume deep-dive II.** Write S4–S10. Then do 10 rapid-fire questions from §3.9 aloud (60–90 s each), recorded |
| 17:15–18:45 | Interview (gap) | **D2-6 G2 flaky tests + G3 CI/CD.** Read the 2 Google posts, Fowler, and the pytest flaky page (40 min). Then **Lab step 2**: flaky demos, CI YAML, flaky policy |
| 18:45–19:45 | — | Dinner |
| 19:45–21:00 | Both | **D2-7 MCQ/Linux.** 6 ★ shell drills from §2.7 (40 min). Then A2/A3 gotchas and G8 bug lifecycle (20 min) |
| 21:00–21:30 | Both | Update `errors.md`. Re-solve one mock problem you lost points on, from a blank editor |

**Set C:** [LC 200](https://leetcode.com/problems/number-of-islands/) (iterative BFS) → [LC 994](https://leetcode.com/problems/rotting-oranges/) → [LC 207](https://leetcode.com/problems/course-schedule/) → [Components in a graph](https://www.hackerrank.com/challenges/components-in-graph/problem) (union-find) → [LC 743](https://leetcode.com/problems/network-delay-time/) → [LC 278](https://leetcode.com/problems/first-bad-version/) → [LC 875](https://leetcode.com/problems/koko-eating-bananas/) → [LC 435](https://leetcode.com/problems/non-overlapping-intervals/). Stretch: [Castle on the Grid](https://www.hackerrank.com/challenges/castle-on-the-grid/problem), [LC 721](https://leetcode.com/problems/accounts-merge/).

### 3.4 THE MOCK — Sat Oct 24, 09:00–10:35 (exactly 95 min)
**Conditions:**
- Chrome full-screen, phone in another room, no AI, no docs, no other tabs.
- Paper and pen. A visible timer.
- Open the three problem links at 08:58. **Don't read them before then.**

| Clock | Item | Target | Why it's in the set |
|---|---|---|---|
| 09:00–09:12 | **Part A: 16 MCQs.** Appendix B, on paper (≈ 45 s each). Note "confident / guessed" per answer | 12 min | Configuration B rehearsal; negative-marking discipline |
| 09:12–09:27 | **Q1 [Time Delta](https://www.hackerrank.com/challenges/python-time-delta/problem)** (HR, Medium) | 15 min | Timestamp parsing with tz offsets (`%z`), done from memory |
| 09:27–09:59 | **Q2 [Fraudulent Activity Notifications](https://www.hackerrank.com/challenges/fraudulent-activity-notifications/problem)** (HR, Medium) | 32 min | Sliding-window median. Naive sort-per-day times out on big tests, so it rehearses the partial-credit decision (counting array over 0..200, or `bisect.insort`) |
| 09:59–10:31 | **Q3 [Roads and Libraries](https://www.hackerrank.com/challenges/torque-and-development/problem)** (HR, Medium) | 32 min | Connected components. Edge case `c_lib <= c_road`; recursion-depth trap (go iterative or use union-find) |
| 10:31–10:35 | Final pass: every question **submitted**, MCQs reviewed | 4 min | Test-day habit |

**Triage rule:** at minute 15 of any question with no working approach, write the brute force, submit it for partial credit, and move on. Come back if time remains.

**Score sheet** (write it down immediately):
```
Q   | tests passed | minutes | first-submit at | time split read/plan/code/debug | labels
MCQ | __/16 (guessed: __) |
Q1  | __/__ | ...
Q2  | __/__ | ...
Q3  | __/__ | ...
```
**Benchmarks:**
- Q1 full plus Q2 or Q3 full ≈ on track.
- All three full and ≥ 12/16 MCQ ≈ strong. Shift Sunday time toward interview prep.
- Under 1.5 problems ≈ move Sunday's D3-3 lab to a conceptual pass, and give that time to DSA re-solves.

### 3.5 Same-day review method (Sat 10:50–12:20, 90 min)
This is Zeval applied to yourself: score → failure taxonomy → targeted re-run.
1. **Score (10 min).** Fill in the score sheet honestly: minutes per phase, and when the first green submit happened.
2. **Label every lost point (20 min)** with exactly one tag:
   - **K** didn't know the pattern
   - **I** knew it, implementation too slow
   - **B** bug
   - **E** missed edge case
   - **T** TLE / complexity
   - **F** I/O or format mismatch
   - **M** triage / time management
   - **R** misread the statement
3. **Cold re-solve (35 min).** Close everything and re-solve your worst problem from blank at ⅔ of the original time. Only *then* read the Discussions tab for the optimal approach, and implement it if it differs.
4. **Explain cards (15 min).** For Q1–Q3, write 5 lines each: problem in one line · key insight · complexity · edge cases + how you'd test it · what you'd change. Say each card aloud in 60 s. **This is exactly Tuesday's first interview segment.**
5. **Rules and routing (10 min).**
   - Write one rule per label in `errors.md`. Example: "T → compute the operation count from constraints before typing."
   - Reorder Set C so your worst label/pattern comes first.
   - MCQs: read the explanation for every wrong *and* every guessed answer.

### 3.6 Day 3 — Sun Oct 25: close the gaps, rehearse the interview
| Time | Track | Block |
|---|---|---|
| 08:30–10:00 | Code | **D3-1 Set D: design-a-class + REST.** [LC 146 LRU](https://leetcode.com/problems/lru-cache/) (OrderedDict *and* dict + doubly linked list) → [LC 981](https://leetcode.com/problems/time-based-key-value-store/) → [LC 1797](https://leetcode.com/problems/design-authentication-manager/) → [Simple Text Editor](https://www.hackerrank.com/challenges/simple-text-editor/problem) → **T4-A and T4-B** (jsonmock, with `urllib`; then redo one with `requests`) |
| 10:15–11:15 | Code | **D3-2 Real-UI rehearsal.** [Problem Solving (Intermediate)](https://www.hackerrank.com/skills-verification/problem_solving_intermediate), or [Basic](https://www.hackerrank.com/skills-verification/problem_solving_basic) if the mock was under 1.5 problems. You get unseen problems in the real proctored UI. Cap yourself at 60 min, then submit whatever you have; the rehearsal matters more than the badge |
| 11:15–11:45 | Code | Short review: steps 1–3 of §3.5 |
| 11:45–12:45 | — | Lunch |
| 12:45–14:45 | Interview (gap) | **D3-3 G4 Docker + G5 Kubernetes + G6 perf/fault injection.** zeval-lite **Lab step 3** on OrbStack's built-in Kubernetes |
| 15:00–16:00 | Interview | **D3-4 G7 AI-for-testing.** Prepare 4 whiteboard mini-designs (test-case generation, flaky classifier, failure clustering, test selection) as 5 bullets each. Re-read S1–S3 |
| 16:00–17:00 | Interview | **D3-5 Full interview rehearsal, 50 min, camera on, recorded:** 5-min intro → walk through your mock Q2/Q3 using the explain cards → 6 technical questions → 3 behavioral → your questions for them. Have a friend ask from §3.9 if you can; otherwise draw 9 questions at random |
| 17:00–17:30 | Interview | Watch the recording. Rewrite the 3 weakest answers |
| 17:30–19:00 | — | Dinner / rest |
| 19:00–20:30 | Code | **D3-6 Redo** every `errors.md` problem from blank, timed. If the error log is short, do 30 min of SQL ([The Report](https://www.hackerrank.com/challenges/the-report/problem), [Top Competitors](https://www.hackerrank.com/challenges/full-score/problem), [LC 185](https://leetcode.com/problems/department-top-three-salaries/)) |
| 20:30–21:00 | Both | **D3-7** Write a one-page handwritten cheat sheet (templates, gotchas, story keywords). You'll read it Tuesday morning, not during the test |

### 3.7 Mon Oct 26 — taper
| Time | Block |
|---|---|
| 09:30–10:30 | 3 speed re-solves from blank, ≤ 15 min each: [LC 560](https://leetcode.com/problems/subarray-sum-equals-k/), [LC 636](https://leetcode.com/problems/exclusive-time-of-functions/), [Roads and Libraries](https://www.hackerrank.com/challenges/torque-and-development/problem) |
| 10:30–11:00 | Read S1–S10 and the §3.9 trigger table aloud once |
| **14:00–14:45** | **Logistics dry-run at the test's clock time.** Work through the §4.1 checklist, with VPN **off** |
| Evening | Nothing new. Light exercise. Lights out by 23:00 |

Optional, send by Friday: a one-line note to the recruiter confirming the interview starts right at 15:35, back-to-back with the test. If they offer 15:40, take it.

---

### 3.8 Interview prep: resume deep-dive

**Positioning (30 seconds; memorize the shape, not the words):**
> "I build verification for AI systems. At Ztalk I created Zeval, the evaluation and regression system for our customer-service LLM agent MyQA, which runs on Taobao, JD and Douyin. Zeval is a curated suite of case snapshots that makes agent runs reproducible. Deterministic metrics are the primary oracle, and an LLM evaluator calibrated against reference judgments covers what metrics can't capture. It grew into ztalk-mcp, a shared stateless MCP service. Before that I did failure analysis for automotive perception at Axera and defect-detection models at Bosch. The thread is the same: make AI behavior measurable and catch regressions before users do. That's what this role does at NVIDIA scale."

**90-second 'tell me about yourself':** TU Berlin M.Sc. Computer Engineering (ICARM paper, dynamic object detection) → Bosch: defect detection (Mask R-CNN/U-Net), synthetic data from Blender/CAD → Axera: detection-model failure analysis, annotation workflows, ISP/image quality → Ztalk: MyQA agent, Zeval, ztalk-mcp, Azure voice-agent perf harnesses → why SDET now (S10).

**Vocabulary translation** (say the right-hand column to an SDET panel):
| Your Ztalk term | SDET framing |
|---|---|
| Case snapshot | **Hermetic test fixture.** Frozen input plus the external evidence state, so a run is reproducible and independent of live systems |
| Hand-curated case dataset (built with a collecting Codex agent) | **Versioned golden regression suite**, with agent-assisted test-case collection and reference labels |
| Verdict correctness / evidence-consultation completeness / remediation-route agreement | **Deterministic oracles**: functional correctness, process/coverage assertion (did it consult the required evidence), decision-path agreement |
| Evaluator Analysis Meta-Agent calibrated against per-case judgments | **LLM-as-judge oracle, validated against reference labels** with measured agreement. Versioned, so scores stay comparable across runs |
| "Scoring outlives the session" | Scores are **reproducible and comparable over time**, with no dependence on the context that produced the labels |
| AutoResearch loops | **Automated failure analysis / root-cause exploration**, gated by eval |
| ztalk-mcp (stateless, MCP [2026-07-28 spec](https://modelcontextprotocol.io/docs/2026-07-28/getting-started/intro)) | **Shared tooling service.** Stateless means it scales horizontally, has no session affinity, is easy to containerize, and each call can be contract-tested in isolation |
| Git-based agent-plugin registry | **Config-as-code tool registry**: versioned, reviewed, rollback-able |
| Azure voice-agent perf harness | **Load/latency test harness**: p50/p95/p99, concurrency, stage breakdown |
| Axera failure analysis → annotation/data fixes | **Defect triage, root cause, fix, verify**: the bug lifecycle |
| Bosch synthetic data | **Test-data generation for rare cases**: coverage of the long tail |

**JD → evidence map (and how to state each gap):**
| JD item | Your evidence | Story | Gap / honest phrasing |
|---|---|---|---|
| AI-powered test-case generation | Codex-agent-collected case dataset; Bosch synthetic rare-defect data | S1, S7 | Code-level unit-test generation: "here's how I'd build it" (G7) |
| Defect detection | Bosch and Axera detection work | S6, S7 | Vision domain. Same discipline: precision/recall trade-off, false positives cost triage time |
| Flaky-test & regression analysis | Separating agent non-determinism from real regressions in Zeval | S4 | You haven't run CI flaky dashboards. Cover with G2 + Lab step 2 |
| Coverage optimization | Evidence-consultation completeness; curating the suite for scenario coverage | S1 | Code coverage and test selection tooling: G1/G7 |
| Functional / performance testing | Zeval; Azure perf harnesses | S1, S5 | — |
| Fault injection / reliability, cloud-native | ztalk-mcp's stateless design | S3 | **No K8s/chaos in production.** Say so; then the Lab step 3 story |
| Scalable test frameworks | Zeval architecture; plugin registry | S1, S3 | pytest-specific: G1 + zeval-lite |
| Bug lifecycle | Axera triage → fix → verify loop | S6 | Jira-style workflow vocabulary: G8 |
| Python / Linux / shell | Daily work | — | — |
| K8s / containers / CI-CD | [fill: what you actually used, e.g. Docker at Axera/Ztalk, any CI] | S9 | Don't stretch it. Be specific about what you've touched |
| MS/PhD | TU Berlin M.Sc. + ICARM paper | — | — |
| 5+ yrs QA automation | [fill: years spent on evaluation/validation/failure analysis across Bosch/Axera/Ztalk] | S10 | "Test and eval infrastructure for AI systems", not "QA engineer". Don't inflate titles |

**Story cards.** Each card is Hook → Problem → What I built (SDET terms) → Proof [fill] → Follow-ups. Keep the spoken version to 2 minutes.

- **S1 Zeval (anchor story).**
  - *Problem:* changes to the MyQA agent (prompts, retrieval, model versions) had no reliable regression signal. Outputs are non-deterministic, and spot checks didn't scale. [fill: release cadence, cost of a bad release]
  - *Built:*
    1. Case-snapshot suite collected with a Codex agent that also recorded per-case judgments, so the cases are hermetic and replayable.
    2. Three deterministic oracles (verdict, evidence completeness, route agreement).
    3. A meta-agent judge calibrated against those judgments, for analysis the metrics can't express.
  - *Proof:* [fill: #cases, #regressions caught, a decision Zeval changed, run time].
  - *Follow-ups:* How do cases get added and retired? How do you avoid overfitting the agent to the suite (held-out cases, refreshing from production)? How is the suite versioned? Is it in CI? If not: "here's the CI design" (zeval-lite).
- **S2 Judge calibration.**
  - Calibration set with reference labels → agreement measured [fill: % / κ] → review the confusion matrix on disagreements → fix the rubric.
  - Known LLM-judge failure modes: position bias, verbosity bias, self-preference, drift on model updates.
  - Mitigations: structured rubric output, pinned model/version/prompt, temperature 0, recalibration on any change, periodic human audit.
  - Key line: *"A judge is a test oracle, and an oracle needs its own test suite."*
- **S3 ztalk-mcp.**
  - Grew out of Zeval because agents and the evaluator needed the same tool access.
  - Stateless per the 2026-07-28 MCP spec, so any replica can serve any call. That makes it easy to scale behind a load balancer and easy to test, since there's no hidden session state.
  - The Git-based plugin registry gives versioned, reviewable tools.
  - Testing [fill: what exists]. What you'd add: schema/contract tests per tool, golden-response tests, idempotency and concurrency tests, fault injection (backend timeout, malformed payload), and compatibility tests across plugin versions.
- **S4 Non-determinism vs regression.**
  - Repeated runs per case; compare *distributions*, not single runs.
  - Thresholds with sample sizes big enough to mean something (see B15: 18/20 vs 15/20 is *not* significant).
  - Cases that disagree across reruns of the same version are flaky by definition, the same definition Google uses: pass and fail on the same code.
  - Freezing evidence removes external variance. [fill: an actual incident]
- **S5 Azure voice-agent perf harness.**
  - Workload model (concurrent sessions, call length).
  - End-to-end latency broken into stages (ASR → LLM → TTS), reported as p50/p95/p99, plus error rate.
  - The bottleneck you found and the fix [fill].
  - How you'd turn it into a CI perf gate: a baseline, a tolerance band, noise handling.
- **S6 Axera failure analysis.** Detection failures grouped into categories [fill: e.g. small/occluded objects, night/glare via ISP, label errors] → root cause → fix (data, annotation, ISP tuning) → verify on a regression set. That is a bug lifecycle with severity and priority. Mention the annotation-workflow changes you drove.
- **S7 Bosch defect detection + synthetic data.** Rare defects meant too few real samples, so you generated Blender/CAD synthetic data to cover the long tail. Same idea as AI-generated test cases: generate inputs where real coverage is thin, then validate that they help (held-out real defects) [fill: metric lift].
- **S8 AutoResearch loops.** An automated hypothesis → experiment → eval loop with an eval gate as the stop/accept criterion. In SDET terms: AI-driven root-cause exploration, where the safety comes from the gate. [fill: one concrete loop and its result]
- **S9 The Kubernetes gap (say it straight).**
  > "I haven't operated Kubernetes in production; my services ran on [fill]. This weekend I containerized a pytest eval suite and ran it as a Kubernetes Job. I debugged an OOMKilled pod and an ImagePullBackOff, and watched a Deployment self-heal after I killed a pod. Concepts I'm solid on: pods, deployments, services, probes, requests/limits. In the first month I'd get hands-on with the team's cluster tooling and chaos setup."
- **S10 Why SDET / why NVIDIA.** "In agent engineering the bottleneck has moved from generating behavior to verifying it. I've spent [fill] years building verification for AI systems as a side responsibility. I want it to be the job, on the platform where agents and cloud-native infrastructure are being built."

**Confidentiality:** describe Ztalk systems at the architecture level. Don't screen-share internal code, prompts, customer data or dashboards.

### 3.9 Likely interview questions → the story or answer each should trigger
| # | Question | Trigger | Points to hit |
|---|---|---|---|
| 1 | Walk me through your Q2 solution | §4.5 card | Insight → algorithm → complexity → status → what failed and why → fix |
| 2 | Complexity? Can you do better? | — | State the bound from constraints. Name the trade-off (memory vs time) |
| 3 | Which hidden tests failed, and why? | §3.5 labels | Own it precisely: "TLE on large n because…" |
| 4 | **How would you test this function?** | §4.5 EBIDPP | Equivalence classes, boundaries, invalid input, differential vs brute force, property-based (Hypothesis), performance at max n; pytest parametrize |
| 5 | Make it production-ready / input is a 50 GB log | — | Streaming generator, bounded memory (heap of size k), chunking/external sort, input validation, logging, tests |
| 6 | How do you test an agent whose outputs are non-deterministic? | S1, S4 | Hermetic snapshots → deterministic oracles first → calibrated judge second → repeated runs + statistics |
| 7 | How do you know your LLM judge is right? | S2 | Calibration set, agreement/κ, disagreement review, pinning, recalibration |
| 8 | Use AI to generate test cases for a cloud service | S1, S7, G7 | Inputs: spec/OpenAPI + diff + past bugs → LLM proposes → run → dedupe → keep only cases that add coverage or kill mutants → human review. The oracle problem is the hard part |
| 9 | Design a flaky-test detection system | G2, T1 | Definition; signals (same-SHA reruns, flip rate, duration variance, error-signature variance); quarantine with SLA + owner; never auto-pass on rerun; dashboard |
| 10 | Pass rate dropped 97% → 93% overnight. Go | S4, G2 | Split infra vs product vs test; cluster by failure signature; compare to the flaky baseline; diff env (image digest, deps, **model version**); bisect (LC 278); reproduce; file with evidence |
| 11 | CI takes 3 h. Cut it | G3, G7 | Test impact analysis (changed files → covering tests), prioritize by historical failure probability, shard/parallelize (xdist, K8s Jobs), tier presubmit vs nightly, dedupe redundant tests |
| 12 | Defect detection from logs with AI | S6, G7 | Parse logs into templates, anomaly detection, cluster failure signatures (embeddings), link to known bugs, auto-triage; precision matters (triage cost) |
| 13 | How would you test an MCP server / tool-using agent? | S3 | Schema contract tests, golden responses, statelessness/idempotency, concurrency, fault injection (timeouts, malformed responses), version compatibility |
| 14 | Design a scalable test framework | G1, T5 | Layers (tests → fixtures/resources → clients → config → reporting), data-driven cases, markers/tiers, parallelism and isolation, JUnit XML → CI |
| 15 | pytest: fixture scopes, conftest, parametrize, plugins | G1 | function/class/module/package/session; yield teardown; `conftest.py` discovery; `ids=`; `--strict-markers`; xdist, randomly, rerunfailures, timeout, cov |
| 16 | Common causes of flaky tests and fixes | G2 | Async waits, order dependency, shared state, time/timezone, randomness, unordered collections, network, resource leaks, infra |
| 17 | Test strategy for a new feature | G1 | Risk-based; pyramid; entry/exit criteria; what you automate vs explore |
| 18 | Bug lifecycle; what's a good bug report? | S6, G8 | States, severity vs priority, repro steps, expected vs actual, env, logs, regression range |
| 19 | GIL: threads vs processes vs asyncio for a test runner | A2 | I/O-bound → threads/asyncio; CPU-bound → processes; xdist uses processes |
| 20 | Pod vs Deployment vs Service; debug CrashLoopBackOff | G5, S9 | describe → events → `logs --previous` → exit code / OOMKilled → probes → config/secrets |
| 21 | Readiness vs liveness — and how to test them | G5 | Readiness failing → removed from endpoints; liveness failing → restart. Test by injecting a failing dependency |
| 22 | Design a fault-injection test on K8s | G6 | Steady-state hypothesis (SLO metric) → inject (pod kill, 200 ms latency, packet loss) → observe → limit blast radius + abort conditions → automate nightly |
| 23 | Design a performance test | S5, G6 | Workload model, ramp/soak/spike, p95/p99, throughput, error rate, baseline + tolerance |
| 24 | Run your suite in CI on Kubernetes | G5, T5 | Image → Job per shard → ephemeral namespace → artifacts → cleanup; exit code = verdict |
| 25 | Tell me about yourself | §3.8 | 90 s, end on "why this role" |
| 26 | Algorithm engineer → why SDET? | S10 | Verification is now the bottleneck |
| 27 | JD asks 5+ yrs QA automation — map yours | S10, JD map | Honest year count across roles; ownership of test/eval infrastructure |
| 28 | Biggest regression/bug you caught | S1/S4 [fill] | Concrete, with impact |
| 29 | Disagreed with a dev/PM on quality | [fill] | Data-driven resolution, e.g. deterministic metric vs "looks fine" |
| 30 | No Kubernetes — how will you ramp? | S9 | Weekend lab + concepts + 30-day plan |

**Your questions for them** (pick 3):
- How does the team measure agent quality today, and where is it weakest?
- Which AI testing tools are built in-house versus adopted?
- How is time split between framework building and test execution?
- What does CI run on (internal K8s clusters?), and how are flaky tests handled now?
- What would make someone in this seat clearly successful at 6 months?

### 3.10 JD-gap crash-bridge topics (what to learn, and how deep)
| ID | Topic | Depth target ("done when you can…") | Sources (verified) | When |
|---|---|---|---|---|
| **G1** | pytest + test-framework design | …write from memory: fixture with scope + `yield` teardown, `conftest.py`, `parametrize` with `ids`, custom markers + `-m` + `--strict-markers`, `monkeypatch`, `tmp_path`, `capsys`, `skip`/`xfail`; name the plugins (xdist, randomly, rerunfailures, timeout, cov) and pytest exit codes 0–5; sketch framework layers on a whiteboard | [pytest docs](https://docs.pytest.org/en/stable/) · [fixtures](https://docs.pytest.org/en/stable/how-to/fixtures.html) · [fixtures reference](https://docs.pytest.org/en/stable/reference/fixtures.html) · [parametrize](https://docs.pytest.org/en/stable/how-to/parametrize.html) · [marks](https://docs.pytest.org/en/stable/how-to/mark.html) · [skip/xfail](https://docs.pytest.org/en/stable/how-to/skipping.html) · [monkeypatch](https://docs.pytest.org/en/stable/how-to/monkeypatch.html) · [tmp_path](https://docs.pytest.org/en/stable/how-to/tmp_path.html) · [--lf/--ff cache](https://docs.pytest.org/en/stable/how-to/cache.html) · [good practices](https://docs.pytest.org/en/stable/explanation/goodpractices.html) · [hooks](https://docs.pytest.org/en/stable/how-to/writing_hook_functions.html) · [exit codes](https://docs.pytest.org/en/stable/reference/exit-codes.html) · [unittest.mock](https://docs.python.org/3/library/unittest.mock.html) · [Hypothesis](https://hypothesis.readthedocs.io/en/latest/) · [pytest-xdist](https://pytest-xdist.readthedocs.io/en/stable/) · [Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html) | Fri D1-5 |
| **G2** | Flaky-test theory | …define flaky (pass *and* fail on the same code); quote Google's numbers: ~1.5% of runs flaky, ~16% of tests with some flakiness, ~84% of pass→fail transitions involving a flaky test; list 8 root causes with a fix each; argue why "retry until green" hides real bugs; describe quarantine (owner + SLA + still running, not counted toward gating) | [Google: Flaky tests and how we mitigate](https://testing.googleblog.com/2016/05/flaky-tests-at-google-and-how-we.html) · [Google: Where flaky tests come from](https://testing.googleblog.com/2017/04/where-do-our-flaky-tests-come-from.html) · [Fowler: Eradicating non-determinism](https://martinfowler.com/articles/nonDeterminism.html) · [pytest: flaky tests](https://docs.pytest.org/en/stable/explanation/flaky.html) · [pytest-randomly](https://github.com/pytest-dev/pytest-randomly) · [pytest-rerunfailures](https://github.com/pytest-dev/pytest-rerunfailures) | Sat D2-6 |
| **G3** | CI/CD | …write a GitHub Actions workflow from memory (trigger, matrix, setup-python with pip cache, run pytest, upload JUnit artifact with `if: always()`); explain presubmit vs nightly, gating vs non-blocking lanes, artifacts, caching, sharding, test impact analysis | [GH Actions quickstart](https://docs.github.com/en/actions/get-started/quickstart) · [Building & testing Python](https://docs.github.com/en/actions/tutorials/build-and-test-code/python) · [Matrix jobs](https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations) · [GitLab CI](https://docs.gitlab.com/ci/) | Sat D2-6 |
| **G4** | Containers | …explain image vs container vs layer; why `COPY requirements.txt` comes before `COPY . .`; multi-stage builds; volumes; container exit code → CI verdict; compose for SUT + dependencies | [Docker get started](https://docs.docker.com/get-started/) · [What is a container](https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/) · [Multi-stage](https://docs.docker.com/build/building/multi-stage/) · [Compose](https://docs.docker.com/compose/) | Sun D3-3 |
| **G5** | Kubernetes for test engineers | …explain Pod / Deployment / ReplicaSet / Service / ConfigMap / Secret / Job / Namespace; readiness vs liveness vs startup probes; requests/limits and OOMKilled; debug CrashLoopBackOff and ImagePullBackOff with `get`/`describe`/`logs --previous`/`events`; run tests as a Job; ephemeral namespace per PR; PodDisruptionBudget | [K8s basics](https://kubernetes.io/docs/tutorials/kubernetes-basics/) · [Overview](https://kubernetes.io/docs/concepts/overview/) · [Pods](https://kubernetes.io/docs/concepts/workloads/pods/) · [Pod lifecycle](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/) · [Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/) · [Resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) · [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) · [Jobs](https://kubernetes.io/docs/concepts/workloads/controllers/job/) · [Services](https://kubernetes.io/docs/concepts/services-networking/service/) · [Disruptions](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/) · [Debug pods](https://kubernetes.io/docs/tasks/debug/debug-application/debug-pods/) · [kubectl quick ref](https://kubernetes.io/docs/reference/kubectl/quick-reference/) · [OrbStack K8s](https://docs.orbstack.dev/kubernetes/) · [kind quick start](https://kind.sigs.k8s.io/docs/user/quick-start/) | Sun D3-3 |
| **G6** | Performance, fault injection, reliability | …distinguish load / stress / soak / spike; report p50/p95/p99 + throughput + error rate against a baseline; state the chaos loop (steady-state hypothesis → inject → observe → limit blast radius → automate); name tools (Locust, k6, Chaos Mesh, LitmusChaos, Toxiproxy); explain retry + backoff + jitter, timeouts, idempotency, circuit breakers | [Principles of Chaos](https://principlesofchaos.org/) · [Chaos Mesh](https://chaos-mesh.org/docs/) · [LitmusChaos](https://litmuschaos.io/) · [Toxiproxy](https://github.com/Shopify/toxiproxy) · [Locust](https://docs.locust.io/en/stable/) · [k6](https://grafana.com/docs/k6/latest/) · [Google SRE: Testing for reliability](https://sre.google/sre-book/testing-reliability/) | Sun D3-3 |
| **G7** | AI for testing (your strength; give it structure) | …give a 5-bullet design for each: (1) LLM test-case generation with an oracle strategy and mutation/coverage filtering; (2) flaky classifier (flip rate, duration variance, error-signature features); (3) failure clustering / auto-triage (log templates + embeddings); (4) test selection / prioritization (change → coverage map + failure history); plus agent testing (trajectory/tool-call checks, hermetic replay, judge calibration, statistical gates) | Your own Zeval material plus G1/G2 sources | Sun D3-4 |
| **G8** | Bug lifecycle | …recite New → Triaged → Assigned → In Progress → Fixed → Verified → Closed (and Reopened); explain severity vs priority with an example of each mismatch; give a good-report template; name the metrics (escape rate, MTTR, reopen rate) | — (conceptual) | Sat D2-7 |

**G2 key content to memorize** (root cause → fix):
- Async/timing waits → poll with a deadline, or wait on an event; never a fixed `sleep`.
- Order dependency / shared state → isolate with fixtures; run randomized order (pytest-randomly).
- Time / timezone / DST → inject a clock; freeze time.
- Randomness → seed it, or inject the RNG.
- Unordered collections → compare sets or sorted lists.
- Concurrency / races → deterministic scheduling and locks in the system under test.
- Network / external services → hermetic fakes (`responses`, recorded fixtures). This is **what your case snapshots already do**.
- Resource leaks / port collisions → per-test temp dirs and ephemeral ports.
- Infra (noisy neighbors, OOM) → resource requests; separate infra failures from test failures.
- LLM non-determinism → statistical assertions over N runs, pinned model version, temperature 0 where you can, snapshot the evidence.

---

## 4. Test-day checklist (Tue Oct 27)

### 4.1 Setup: dry-run Monday at 14:00, re-check Tuesday at 13:00
- [ ] **Chrome:** updated. Make a **fresh Chrome profile with no extensions** (no AI sidebars, translators, Grammarly). HackerRank supports Chrome, Firefox and Edge; Brave isn't supported ([browser support](https://candidatesupport.hackerrank.com/articles/3310749702-browser-recommendations-for-hackerrank-tests)).
- [ ] **VPN off.** Check that hackerrank.com and Teams both load quickly from your network. Prefer wired Ethernet, power plugged in, **one display**.
- [ ] **Quit every AI app and agent:** Claude, ChatGPT, Codex, Cursor, Copilot, Amp, and similar. Also quit WeChat/DingTalk/Feishu, and turn on macOS Focus / Do Not Disturb.
- [ ] **Teams:** app updated and signed in (or the guest link tested). Run a test call to check camera, mic and speaker.
- [ ] **Screen sharing:** grant **System Settings → Privacy & Security → Screen & System Audio Recording → Microsoft Teams**. Teams has to restart after this, so do it Monday. Practice sharing a *single window*. Help: [Teams support](https://support.microsoft.com/en-us/teams/).
- [ ] **Local coding window for the interview:** VS Code with **all AI extensions disabled** (or a plain editor) plus a terminal running `python3`. Font size ≥ 16. Have an empty `scratch.py` open.
- [ ] **Room:** light in front of you, camera at eye level, quiet, headset, water, paper + 2 pens.
- [ ] **Links:** star the HackerRank invitation email and the Teams invite.

### 4.2 Timeline
| Time | Action |
|---|---|
| 08:00 | Wake, normal breakfast |
| 10:00–10:40 | Warm-up: 2 problems you've already solved + type Appendix A1 once. No new problems |
| 11:30 | Light lunch. You'll be "on" from 14:00 to ~16:25 |
| 12:30–13:00 | Read your handwritten cheat sheet and S1–S10 keywords, then put them away |
| 13:00–13:30 | Run the §4.1 checks. Test Teams, then **quit Teams** so nothing pops up during the test |
| 13:30–13:55 | Bathroom, water. Open the test link and read the instructions page (number and type of questions, negative marking, whether an AI Assistant panel exists). If a Sample Test is offered and you have spare minutes, use it |
| **14:00** | Start the test |
| **15:28** | Final submit check: every coding question **Submitted** (not just Run), every MCQ answered or deliberately skipped |
| 15:28–15:32 | On paper, 3 lines per question: approach · complexity · what failed or was unfinished, and why |
| 15:32–15:34 | Open Teams and join. Camera on |
| 15:35 | Interview |

### 4.3 HackerRank tactics
**First 3–5 minutes:** open every question, read the constraints, and pick an order. Easiest and highest-value first, never the hardest first.

**Time allocation:**
| If the test is… | Plan |
|---|---|
| 3 coding | 4 min read-all → Q-easy ~18 → Q-med ~30 → Q-med/hard ~35 → 5 min buffer and submit check |
| 2 coding + MCQs | One fast MCQ pass at ≤ 1 min each, flag the uncertain ones (≈ 15–20 min). Then 2 × ~32 min coding. Then flagged MCQs with whatever is left |
| 4 coding | Two easy ones fast (≤ 15 each) → the two hard ones split the rest. Brute force first |

**Per-question loop:**
1. Read the constraints and derive the complexity target (A4).
2. Write 3 edge cases on paper.
3. Code the clean solution.
4. **Run Code.** Add your own custom input (empty/min, duplicates, max-ish).
5. **Submit.**
6. Improve, then re-submit.

**Partial credit:**
- If you have no full approach at minute 12–15, ship a correct brute force. It usually passes the small hidden cases.
- Then optimize, and only re-submit if the new version passes everything the old one did.

**Avoiding Python timeouts:**
- Read big input with `sys.stdin.readline`/`sys.stdin.buffer` (full-program questions only).
- Use `deque.popleft()`, never `list.pop(0)`.
- Build strings with `''.join`, not `+=` in a loop.
- Use iterative DFS/BFS (or `sys.setrecursionlimit`, which only partly protects you).
- `heapq` and `bisect` beat re-sorting.
- Precompute outside loops.

**Output exactness:**
- Match the expected format character for character: spacing, rounding (`f"{x:.2f}"`), trailing newlines.
- In **function-stub** questions, the template writes your return value to the output file and `print()` goes to a separate debug pane ([code stubs](https://candidatesupport.hackerrank.com/articles/2149732827-debugging-the-logic-in-functions-code-stubs), [custom input](https://candidatesupport.hackerrank.com/articles/2715283041-debug-using-custom-input-values)). In **full-program** questions, remove debug prints before you submit.
- Don't rewrite the template's I/O unless you have to.

**MCQs:** if the instructions mention negative marking, only answer when you can eliminate at least 2 options.

**Integrity:**
- Stay full-screen and don't switch tabs. Both are flagged ([test integrity](https://candidatesupport.hackerrank.com/articles/9579706989-malpractices-in-tests)).
- No AI unless the onboarding explicitly enables HackerRank's built-in assistant. Even then, use it at most for syntax, since you'll defend every line minutes later.
- Paper scratch work is normal.

**Write for the interviewer:** small helper functions, clear names, and a one-line comment with the complexity. No code golf.

**Stuck or panicking:** write down the brute force, its complexity, and the bottleneck. Naming the bottleneck usually points to the data structure you need.

### 4.4 The 15:28–15:35 switch
- Submit, then write the paper notes. Don't spend the last 7 minutes squeezing one more test case out of a question.
- If a question is unfinished, your notes say *what the full solution would be*. You'll offer it in the interview.

### 4.5 In the interview: discussing your solutions
**Open proactively**, after the greeting:
> "Quick summary of the test: Q1 I solved fully with X in O(n log n). Q2 passes most cases. The remaining ones time out because I sort the window every day; the fix is a counting array, which gives O(n·200). Q3…"

Owning failures precisely is a strong SDET signal.

**Per-question 60-second card:** problem in one line → key insight → algorithm → complexity (time/space) → status → what failed and why → how I'd fix it → **how I'd test it**.

**"How would you test this?" (EBIDPP):**
- **E**quivalence classes (typical inputs per class)
- **B**oundaries (empty, 1 element, max n, min/max values, duplicates, already sorted / reverse sorted)
- **I**nvalid input (types, malformed lines, negatives, unicode/whitespace)
- **D**ifferential testing against a brute-force oracle on random small inputs
- **P**roperty-based (Hypothesis: invariants such as "output is a permutation" or "sum is preserved")
- **P**erformance at the maximum constraints (timed)

Then: "in CI, as parametrized pytest cases plus one Hypothesis test."

**Expect a follow-up change:** "inputs now stream", "make it thread-safe", "add unit tests", "the range is now 10⁹". Practice: for each mock problem, write 4 pytest tests in 5 minutes (Sunday rehearsal).

**Screen-share hygiene:**
- Share one window. Close everything else.
- No Ztalk internals on screen.
- Think aloud while coding, and say what you're testing before you run it.

**If you blank:** restate the problem, solve a tiny example by hand, name the brute force and its bottleneck. Interviewers grade the process.

---

## Appendix A — memorize before Tuesday (no docs during the test)

### A1. Standard library and templates
```python
import sys, re, math, heapq, bisect
from collections import Counter, defaultdict, deque, OrderedDict
from itertools import groupby, accumulate, combinations, permutations, product, pairwise
from functools import lru_cache, cmp_to_key, reduce
from datetime import datetime, timedelta, timezone

data = sys.stdin.buffer.read().split()        # bulk input (full-program questions)
input = sys.stdin.readline                    # fast line input
cnt = Counter(words); cnt.most_common(3)      # ties keep insertion order -> sort yourself if a tie rule is given
ranked = sorted(cnt.items(), key=lambda kv: (-kv[1], kv[0]))   # count desc, name asc
g = defaultdict(list); g[u].append(v)
q = deque([s]); q.popleft(); q.appendleft(x)
h = []; heapq.heappush(h, (prio, idx, item)); heapq.heappop(h)  # idx = tie-breaker; max-heap: push -x
heapq.nlargest(k, xs, key=f)
i = bisect.bisect_left(a, x)                  # first i with a[i] >= x ; bisect_right: first a[i] > x
bisect.insort(win, x); win.pop(bisect.bisect_left(win, old))     # sorted sliding window
runs = [(k, len(list(grp))) for k, grp in groupby(s)]            # run-length (adjacent only)
pref = list(accumulate(a, initial=0))         # pref[j] - pref[i] = sum(a[i:j])
@lru_cache(maxsize=None)                      # memoized recursion
sorted(xs, key=cmp_to_key(lambda a, b: -1 if a + b > b + a else 1))
re.findall(r'(\w+)=(\d+)', line)              # list of tuples
m = re.match(r'^(?P<ts>\S+) (?P<lvl>[A-Z]+) (?P<svc>\w+)', line); m['lvl']
datetime.strptime('2026-10-27 14:03:22', '%Y-%m-%d %H:%M:%S')
datetime.strptime('Sun 10 May 2015 13:54:36 -0700', '%a %d %b %Y %H:%M:%S %z')
datetime.fromisoformat('2026-10-27T14:03:22Z')  # 3.11+ accepts 'Z'
(t2 - t1).total_seconds(); t + timedelta(minutes=5)
divmod(n, 60); (a + b - 1) // b               # ceil for ints; float('inf') / math.inf
f"{x:.2f}"  f"{n:05d}"  f"{s:>10}"  f"{n:,}"
```
```python
# BFS on grid
def bfs(grid, sr, sc):
    R, C = len(grid), len(grid[0]); dist = [[-1] * C for _ in range(R)]
    dist[sr][sc] = 0; q = deque([(sr, sc)])
    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] != '#' and dist[nr][nc] < 0:
                dist[nr][nc] = dist[r][c] + 1; q.append((nr, nc))
    return dist

# Union-find
parent = list(range(n)); size = [1] * n
def find(x):
    while parent[x] != x:
        parent[x] = parent[parent[x]]; x = parent[x]
    return x
def union(a, b):
    ra, rb = find(a), find(b)
    if ra == rb: return False
    if size[ra] < size[rb]: ra, rb = rb, ra
    parent[rb] = ra; size[ra] += size[rb]; return True

# Topological sort (Kahn) -- cycle if len(order) < n
indeg = [0] * n; adj = defaultdict(list)
for a, b in edges: adj[a].append(b); indeg[b] += 1
q = deque(i for i in range(n) if indeg[i] == 0); order = []
while q:
    u = q.popleft(); order.append(u)
    for v in adj[u]:
        indeg[v] -= 1
        if indeg[v] == 0: q.append(v)

# Dijkstra
dist = {src: 0}; h = [(0, src)]
while h:
    d, u = heapq.heappop(h)
    if d > dist.get(u, math.inf): continue
    for v, w in adj[u]:
        if d + w < dist.get(v, math.inf):
            dist[v] = d + w; heapq.heappush(h, (d + w, v))

# Binary search on the answer: smallest x with ok(x) True (ok is monotone F..F T..T)
lo, hi = LO, HI
while lo < hi:
    mid = (lo + hi) // 2
    if ok(mid): hi = mid
    else: lo = mid + 1

# Variable sliding window (longest substring without repeats)
last = {}; left = best = 0
for right, ch in enumerate(s):
    if last.get(ch, -1) >= left: left = last[ch] + 1
    last[ch] = right; best = max(best, right - left + 1)

# Prefix sum + hashmap (count subarrays summing to k)
seen = Counter({0: 1}); run = ans = 0
for x in nums: run += x; ans += seen[run - k]; seen[run] += 1

# Merge intervals
out = []
for s, e in sorted(iv):
    if out and s <= out[-1][1]: out[-1][1] = max(out[-1][1], e)
    else: out.append([s, e])

# Monotonic stack (days until warmer)
res = [0] * len(T); st = []
for i, t in enumerate(T):
    while st and T[st[-1]] < t:
        j = st.pop(); res[j] = i - j
    st.append(i)
```

### A2. Python gotchas (planted bugs and MCQ material)
- **Mutable default arguments** persist across calls → use `None` and create inside the function.
- **`[[0]*m]*n`** gives n references to one row → use `[[0]*m for _ in range(n)]`.
- **Late-binding closures:** `[lambda: i for i in range(3)]` all return 2 → `lambda i=i: i`.
- **`//` floors toward −∞:** `-7 // 2 == -4`. `%` takes the sign of the divisor: `-7 % 2 == 1`. **`round(2.5) == 2`** (banker's rounding). Compare floats with `math.isclose`.
- **`is` vs `==`:** never use `is` for value comparison (only for `None`).
- **Mutating a dict or set while iterating** → `RuntimeError`. Iterate over `list(d)`.
- **Return values:** `list.sort()` returns `None`; `sorted()` returns a new list. Both are **stable**, which is the trick for multi-key sorts.
- **Generators** are exhausted after one pass.
- **`finally`** runs even after a `return`.
- **Bare `except:`** also catches `KeyboardInterrupt`/`SystemExit` → catch `except Exception`.
- **Copies:** shallow (`copy.copy`, `list[:]`) vs deep (`copy.deepcopy`).
- **Hashing:** defining `__eq__` without `__hash__` makes instances unhashable. Use `@dataclass(frozen=True)` for hashable records.
- **GIL:** threads overlap I/O waits but not CPU work → CPU-bound work needs `multiprocessing` / `ProcessPoolExecutor`; I/O-bound work can use threads or `asyncio`. Docs: [concurrent.futures](https://docs.python.org/3/library/concurrent.futures.html).
- **Decorators** should use `functools.wraps`. Context managers (`with`) guarantee cleanup; pytest `yield` fixtures follow the same idea.
- **pytest exit codes:** 0 all passed · 1 some failed · 2 interrupted · 3 internal error · 4 usage error · 5 no tests collected.

### A3. Linux one-liners
```bash
grep -c ERROR app.log; grep -E 'ERROR|FATAL' app.log; grep -v DEBUG app.log; grep -rn "timeout" src/; grep -o 'req=[0-9]*' app.log
cut -d' ' -f1 access.log | sort | uniq -c | sort -rn | head -5      # top-5 IPs (uniq needs sorted input!)
awk '{s[$3]+=$5} END {for (k in s) print k, s[k]}' metrics.txt       # group-sum col 5 by col 3
awk -F, 'NR>1 && $4 > 500 {print $1}' data.csv                       # filter CSV, skip header
sed -n '10,20p' f; sed 's/foo/bar/g' f; sed -i.bak '/^#/d' f          # print range / replace / delete comments
sort -t, -k2,2nr f; tail -f app.log; tr 'a-z' 'A-Z' < f; paste -sd, f; xargs -n1
find . -name '*.log' -mtime -1 -size +10M; du -sh *; df -h
ps aux | grep pytest; kill -15 PID  # SIGTERM (catchable)  vs  kill -9 PID  # SIGKILL (not catchable)
lsof -i :8080; ss -ltnp; curl -sS -o /dev/null -w '%{http_code}\n' "$HEALTH_URL"   # status code only
chmod 755 run.sh; chmod u+x run.sh; ln -s target link; echo $?    # last exit code
set -euo pipefail                                                  # fail fast in CI scripts
cmd > out.log 2>&1; cmd 2>/dev/null; cmd1 && cmd2 || cmd3; nohup cmd &
```

### A4. Complexity budget (Python 3, HackerRank limit 10 s per test case; assume ~10⁷ simple ops/s)
| n | Feasible |
|---|---|
| ≤ 10 | O(n!) |
| ≤ 20 | O(2ⁿ·n) |
| ≤ 500 | O(n³) |
| ≤ 5·10³ | O(n²) |
| ≤ 10⁶ | O(n log n) or O(n) |
| ≥ 10⁹ | O(log n) / math |

---

## Appendix B — MCQ set (mock Part A; **don't read it before Saturday 09:00**)
1. `def add(x, acc=[]): acc.append(x); return acc` — then `add(1); print(add(2))` → (a) `[2]` (b) `[1, 2]` (c) error (d) `[[1], 2]`
2. `g = [[0]*3]*2; g[0][0] = 1; print(g)` → (a) `[[1,0,0],[0,0,0]]` (b) `[[1,0,0],[1,0,0]]` (c) error (d) `[[1,1,1],[0,0,0]]`
3. `print(-7 // 2, -7 % 2)` → (a) `-3 1` (b) `-4 1` (c) `-3 -1` (d) `-4 -1`
4. `fs = [lambda: i for i in range(3)]; print([f() for f in fs])` → (a) `[0,1,2]` (b) `[2,2,2]` (c) `[0,0,0]` (d) error
5. A runner makes 500 independent HTTP health checks in CPython. The simplest big speed-up: (a) a plain loop (b) `ThreadPoolExecutor` or `asyncio` (c) 500 processes (d) no gain is possible because of the GIL
6. Top-5 most frequent IPs (field 1) in `access.log`: (a) `cut -d' ' -f1 access.log | uniq -c | sort -rn | head -5` (b) `cut -d' ' -f1 access.log | sort | uniq -c | sort -rn | head -5` (c) `sort access.log | uniq -c | head -5` (d) `awk '{print $1}' access.log | sort -rn | head -5`
7. A CI step runs `pytest tests/` and 3 tests fail. The exit code is: (a) 0 (b) 1 (c) 3 (d) 5
8. A field accepts integers 1–100. The minimal two-sided boundary-value set: (a) 1, 50, 100 (b) 0, 1, 100, 101 (c) −1, 0, 101 (d) 1, 100
9. A test passes alone but fails intermittently when the full suite runs in random order. Most likely cause: (a) a slow CI machine (b) shared mutable state / order dependency (c) network (d) a wrong assertion
10. A `@pytest.fixture(scope="module")` is used by 3 tests in `test_a.py` and 2 in `test_b.py` (single process). How many times does the fixture body run? (a) 1 (b) 2 (c) 5 (d) it depends on order
11. `kubectl describe pod` shows `Last State: Terminated, Reason: OOMKilled`, and restarts keep rising. Best next step: (a) raise the readiness-probe timeout (b) compare memory use to `resources.limits.memory`, then raise the limit or fix the leak (c) switch the Service to LoadBalancer (d) delete the namespace
12. A container's readiness probe fails while liveness passes. Kubernetes: (a) restarts the container (b) removes the Pod from Service endpoints without restarting it (c) deletes the Deployment (d) reschedules the Pod to another node
13. Why `COPY requirements.txt .` + `RUN pip install -r requirements.txt` *before* `COPY . .`? (a) a smaller image (b) layer caching: dependencies only reinstall when requirements change (c) security (d) pip requires it
14. A typo in the company name on the home page is: (a) high severity, high priority (b) low severity, high priority (c) high severity, low priority (d) low severity, low priority
15. An agent eval case passes 18/20 runs on model v1 and 15/20 on v2. The right conclusion: (a) v2 regressed 15 points, block the release (b) not significant at this sample size (Fisher exact two-sided p ≈ 0.41), so add trials/cases before deciding (c) the case is flaky, delete it (d) v1 was flaky
16. 1,000 commits separate the last good build from the first bad one, and each test run takes 20 min. Worst-case bisection time: (a) ~20 min (b) ~3.3 h (≈ 10 runs) (c) ~1 day (d) ~333 h

<details><summary>Answer key</summary>

1 b · 2 b · 3 b · 4 b · 5 b · 6 b (`uniq` only collapses *adjacent* duplicates) · 7 b (5 = no tests collected) · 8 b · 9 b · 10 b · 11 b · 12 b · 13 b · 14 b · 15 b · 16 b (⌈log₂1000⌉ = 10 runs × 20 min)
</details>

---

## Appendix C — SDET-flavored practice tasks (sample outputs checked against reference solutions)

**T1. Flaky-test and regression detector** (Fri, 30 min)
*Input:* `N`, then N lines `run_id commit test_name PASS|FAIL duration_ms`. Commit order = order of first appearance.
*Output:*
- For each test with **both PASS and FAIL on the same commit**: `FLAKY <test> <number_of_such_commits>`, sorted by count descending, then name.
- Then, for each test, the **first commit where it went from all-PASS (on its previous commit) to all-FAIL**: `REGRESSION <test> <commit>`, sorted by name.
- If both lists are empty, print `NONE`.
```
12
r1 c1 test_login PASS 120
r2 c1 test_login FAIL 3000
r3 c1 test_search PASS 80
r4 c1 test_upload PASS 200
r5 c2 test_login PASS 110
r6 c2 test_search FAIL 95
r7 c2 test_search FAIL 90
r8 c2 test_upload FAIL 5000
r9 c2 test_upload PASS 210
r10 c3 test_login FAIL 2900
r11 c3 test_login PASS 130
r12 c3 test_search FAIL 85
```
Expected output:
```
FLAKY test_login 2
FLAKY test_upload 1
REGRESSION test_search c2
```
Interview extension: which signals would you add (duration variance, error-message variance), and how would you make this a CI job?

**T2. Log triage** (stretch / Sunday evening)
*Input:* first line `N K W`, then N lines `ISO8601Z LEVEL service latency_ms`. **Lines are not guaranteed to be sorted.**
*Output:*
- Per service, sorted by name: `service total errors error_rate(2dp) p95`. p95 uses nearest rank: sorted latencies at index `ceil(0.95·n) − 1`.
- Then `ALERT service ts` for the first ERROR at which ≥ K of that service's ERRORs fall within the closed window `[ts − W s, ts]`.
```
11 3 60
2026-10-27T14:00:00Z INFO auth 120
2026-10-27T14:00:10Z ERROR auth 900
2026-10-27T14:00:45Z INFO search 80
2026-10-27T14:00:30Z ERROR auth 950
2026-10-27T14:01:05Z ERROR auth 1000
2026-10-27T14:01:20Z ERROR search 300
2026-10-27T14:02:00Z INFO search 70
2026-10-27T14:03:00Z ERROR search 310
2026-10-27T14:03:30Z INFO search 90
2026-10-27T14:03:40Z ERROR search 330
2026-10-27T14:04:10Z INFO auth 110
```
Expected output:
```
auth 5 3 60.00 1000
search 6 3 50.00 330
ALERT auth 2026-10-27T14:01:05Z
```

**T3. `retry` with backoff, plus tests** (Fri D1-5 or Sat D2-6, 30 min)
*Spec:* implement `retry(fn, attempts=3, base_delay=0.1, factor=2, retry_on=(Exception,), sleep=time.sleep)`. It calls `fn()`. On an exception in `retry_on`, it sleeps `base_delay * factor**i` and retries. After the last attempt it re-raises the last exception. Other exceptions propagate immediately. `attempts < 1` raises `ValueError`.
*Write pytest tests for:*
- success on the first call (no sleeps)
- success on the 3rd call (sleeps `[0.1, 0.2]`, using a recording fake `sleep`)
- all attempts exhausted → the original exception is raised
- a non-retryable exception is not retried
- `attempts=1`
- `attempts=0` → `ValueError`

Use `parametrize` for the delay sequences. Then add jitter and explain how you'd test randomness: inject the RNG.

**T4. REST tasks on the jsonmock fixtures** (Sun D3-1). Use `urllib.request` + `json` first, then `requests`. Loop until `page == total_pages`. Answers were computed 2026-10-22; the data is live but static in practice.
- **A.** Total goals Barcelona scored in 2011. Query `team1=Barcelona` (count `team1goals`) and `team2=Barcelona` (count `team2goals`), all pages: [endpoint](https://jsonmock.hackerrank.com/api/football_matches?year=2011&team1=Barcelona&page=1). **Answer: 35** (12 matches). Note that goals come back as strings.
- **B.** Top 3 article names by `num_comments`. Name = `title`, or else `story_title`; skip the article if both are null; break ties by name: [endpoint](https://jsonmock.hackerrank.com/api/articles?page=1). **Answer:** "UK votes to leave EU" (2531), "F.C.C. Repeals Net Neutrality Rules" (1397), "EU approves internet copyright law, including ‘link tax’ and ‘upload filter’" (1010).
- **C.** Count of RUNNING IoT devices and mean `operatingParams.rotorSpeed` (2 dp): [endpoint](https://jsonmock.hackerrank.com/api/iot_devices/search?status=RUNNING&page=1). **Answer: 35 devices, 3087.51.**
- **D.** Total *debit* amount per `userName` (parse strings like `"$1,670.57"`), top 3: [endpoint](https://jsonmock.hackerrank.com/api/transactions?page=1). **Answer:** John Oliver 97285.55 · Bob Martin 85250.00 · Helena Fernandez 65445.13.
- Then write 3 pytest tests for your fetcher **without network access**: monkeypatch `urllib.request.urlopen`, or use [responses](https://github.com/getsentry/responses) for `requests`. Cover pagination, an empty result, and an HTTP error.

**T5. zeval-lite lab: Zeval's ideas in pytest → CI → Docker → Kubernetes.** Use synthetic cases only.

*Step 1, Fri D1-5 (60 min): pytest suite*
```
zeval-lite/
  cases/*.json              # 8 synthetic case snapshots
  zeval_lite/agent.py       # fake agent: returns {"verdict", "evidence_used", "route"}
  zeval_lite/metrics.py     # verdict_correct, evidence_completeness, route_agreement
  tests/conftest.py         # session-scoped cached fake judge, report dir via tmp_path_factory
  tests/test_metrics.py     # unit tests for the metrics (parametrize + edge cases: empty evidence, extra evidence)
  tests/test_cases.py       # one parametrized test per case file
  pytest.ini
```
```json
{"id": "refund-late-delivery-01",
 "input": "My order is 3 days late, I want a refund",
 "evidence": {"order_status": "shipped", "days_late": 3},
 "expected": {"verdict": "eligible", "required_evidence": ["order_status", "days_late"], "route": "refund_flow"}}
```
```python
# tests/test_cases.py
import json, pathlib, pytest
from zeval_lite.agent import run_agent
from zeval_lite.metrics import verdict_correct, evidence_completeness

CASES = sorted((pathlib.Path(__file__).parent.parent / "cases").glob("*.json"))

@pytest.fixture(params=CASES, ids=lambda p: p.stem)
def case(request):
    return json.loads(request.param.read_text())

def test_verdict(case):
    out = run_agent(case)
    assert verdict_correct(out, case["expected"]), out

def test_evidence_completeness(case):
    assert evidence_completeness(run_agent(case), case["expected"]) == 1.0

@pytest.mark.judge
def test_judge_agrees(case, judge):
    assert judge(case, run_agent(case))["agree"]
```
```python
# tests/conftest.py
import json, pytest

@pytest.fixture(scope="session")
def judge():
    cache = {}
    def _judge(case, out):
        key = (case["id"], json.dumps(out, sort_keys=True))
        if key not in cache:   # stub: in real life a pinned-model LLM call, cached so reruns are deterministic
            cache[key] = {"agree": out["verdict"] == case["expected"]["verdict"]}
        return cache[key]
    return _judge
```
```ini
# pytest.ini
[pytest]
markers =
    judge: uses the LLM judge (slow, non-deterministic) -- nightly lane only
addopts = -ra --strict-markers
```
Run: `pytest -m "not judge" -q` · `pytest -n auto` · `pytest --lf` · `pytest --junitxml=reports/junit.xml` · `pytest --cov=zeval_lite --cov-report=term-missing`

*Step 2, Sat D2-6 (50 min): flakiness + CI*
- Add `tests/test_flaky_demo.py` with three classic flaky tests:
  1. `assert random.random() < 0.9`
  2. test A appends to a module-level list, and test B asserts the list is empty
  3. `time.sleep(0.01)` waiting on a background thread
- Expose them by running `for i in $(seq 20); do pytest -q tests/test_flaky_demo.py || echo "FAIL run $i"; done`. pytest-randomly shuffles the order and prints a seed; reproduce with `pytest --randomly-seed=<seed>`. Then fix each properly: inject the RNG, isolate state with a fixture, wait on an event with a timeout.
- Write `.github/workflows/tests.yml` from memory, then compare it with the docs:
```yaml
name: tests
on:
  pull_request:
  schedule:
    - cron: "0 18 * * *"          # nightly (UTC) -> judge lane
jobs:
  presubmit:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.12", "3.13"]
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: pip
      - run: pip install -r requirements.txt
      - run: pytest -m "not judge" -n auto --junitxml=reports/junit.xml
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: junit-${{ matrix.python-version }}
          path: reports/
  nightly-judge:
    if: github.event_name == 'schedule'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-python@v5
        with: { python-version: "3.13", cache: pip }
      - run: pip install -r requirements.txt
      - run: pytest -m judge --reruns 2 --junitxml=reports/judge.xml   # report pass-on-rerun as FLAKY, not PASS
```
- Write a one-page **flaky policy**:
  - definition
  - detection: same-SHA reruns, flip rate
  - quarantine: owner + 7-day SLA, still runs, doesn't gate
  - a rule that reruns are reported, never silently counted as green
  - LLM tests use statistical gates

*Step 3, Sun D3-3 (90 min): container + Kubernetes.* State of this Mac on 2026-10-22: Docker engine 29.8.2 running via **OrbStack** (active context), `kubectl` v1.33.9, **no cluster context yet**, `kind` not installed. Docker Hub pulls may need your VPN on (prep days only).
```dockerfile
FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
ENTRYPOINT ["pytest", "-q", "-m", "not judge"]
```
```bash
docker build -t zeval-lite:dev . && docker run --rm zeval-lite:dev; echo "exit=$?"   # break a test -> exit=1
orb start k8s                       # OrbStack's built-in cluster; local images work with a non-:latest tag
kubectl config get-contexts         # expect an 'orbstack' context
```
```yaml
# job.yaml
apiVersion: batch/v1
kind: Job
metadata: { name: zeval-lite }
spec:
  backoffLimit: 0
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: tests
          image: zeval-lite:dev
          imagePullPolicy: IfNotPresent
          resources:
            requests: { cpu: "250m", memory: "128Mi" }
            limits:   { cpu: "1",    memory: "256Mi" }
```
```bash
kubectl apply -f job.yaml && kubectl get pods -w
kubectl logs job/zeval-lite; kubectl describe job zeval-lite; kubectl get events --sort-by=.lastTimestamp
kubectl delete job zeval-lite
```
Failure drills (each one becomes a sentence in story S9):
1. Add a test that allocates 300 MB with the limit at 256Mi → **OOMKilled** in `describe`.
2. Typo the image tag → **ErrImagePull / ImagePullBackOff**.
3. `kubectl create deployment web --image=nginx --replicas=3`, then `kubectl expose deployment web --port=80`, then `kubectl delete pod <one>` → the ReplicaSet recreates it. Next, add a readiness probe on a wrong path → the pod is Running but not Ready, and `kubectl get endpoints web` is empty.
4. Say out loud how you'd do fault injection with Chaos Mesh (PodChaos pod-kill, NetworkChaos delay) against a steady-state SLO.

Fallback if OrbStack's Kubernetes won't start: `brew install kind && kind create cluster` ([kind quick start](https://kind.sigs.k8s.io/docs/user/quick-start/)), then `kind load docker-image zeval-lite:dev`. Spend at most 15 minutes on installs before switching to the docs-only version of G5.

---

## Appendix D — how the URLs were verified (2026-10-22)
- **Every URL in this file was fetched with `curl -L` and a browser user agent** (some sites reject plain curl).
  - **HackerRank** pages: HTTP 200 with the real page title. A bogus slug returns 404.
  - **Certification pages:** 200 plus the certificate heading. A bogus slug returns 500.
  - **Candidate-support articles:** 200 with the article title.
  - **jsonmock endpoints:** 200 with JSON data. The `/api/users` endpoint returned 400 and isn't used.
- **LeetCode:** leetcode.com HTML returns a Cloudflare bot challenge (403) to curl, so every problem and study plan was verified through LeetCode's GraphQL API. All exist, and none are paywalled. Each problem slug was also fetched on leetcode.cn (200 with a real `NNN. 标题` title; bogus slugs there show an empty title).
- **Excluded after checking:**
  - 6 premium LeetCode problems (listed in §2).
  - `toxiproxy.io`, which now **redirects to an unrelated betting site**. The GitHub repo is linked instead.
  - Two PyPI pages that returned a bot "Client Challenge" (pytest-xdist and responses). Readthedocs/GitHub links are used instead.
  - The HackerRank Regex domain page and `/dashboard`, which land on the logged-in dashboard.
- **NVIDIA's AI-tools policy page could not be located by curl, so no URL is given.** The rule as you were told it (unapproved outside AI tools such as ChatGPT during interviews means disqualification) is the operating assumption throughout.