Lesson 1 of 8 · 48 min

The interview loop and the hire rubric

The four-axis hire rubric, six-step interview loop, company-tier calibration, silent-coding failure mode, and Two Sum as a rubric drill — narration is the skill, code is the artifact.

The silent-coding failure mode

You can ship production systems, own on-call, and still fail a 45-minute coding round. The most common builder failure is not “forgot the algorithm” — it is silent coding: opening the editor and typing for four minutes while the interviewer stares at a cursor. The four axes interviewers grade — Communication, Problem Solving, Technical Competency, Verification — punish silence harder than a suboptimal first approach. This lesson is the ground floor: the loop, the rubric, company-tier calibration, and Two Sum as a rubric drill, not a solution to memorize.

A coding interview is not a whiteboard puzzle contest. It is a short, high-bandwidth collaboration under partial information. The interviewer is your incident partner: they hold constraints you have not asked for, edge cases they will only reveal if you probe, and a scoring sheet that rewards how you frame the work more than how many characters you type. Production engineers often invert this — they optimize for “working code fast” the way they would on a ticket — and score a Hire on Technical Competency while scoring No-Hire on Communication and Verification. One Strong No-Hire axis is usually enough to reject.

The universal four-axis rubric (Google-style bands popularized by Exponent and Tech Interview Handbook; used with local labels at Meta, Amazon, and most product companies) scores each axis 1–4. Hire threshold: roughly ≥3 on every axis; a 2 on Problem Solving is sometimes recoverable with 3s elsewhere; a 1 on any axis is a reject. Strong Hire (4) is rare and requires the interviewer never had to ask “what are you thinking?” — you drove the round.

The four axes, in production language

1. Communication. Thinking aloud in structured updates. Naming assumptions. Asking for help without collapsing. The production metaphor: stand-up narration during an incident — “I am checking X, then Y; if that fails we pivot to Z.” Silence is not “focus”; it is a missing status channel. Band 4: interviewer never had to pull. Band 1: silent, disorganized, or off-topic for long stretches.

2. Problem Solving. Clarifying questions, decomposition, alternative approaches, productive use of hints. The production metaphor: scoping a bug before writing a fix. Band 4: asks constraints first, decomposes, considers brute force then optimal, uses a nudge as course correction. Band 1: stuck, jumps to a random solution, or freezes on a hint.

3. Technical Competency (Coding). Correctness, language fluency, edge cases, idiomatic structure. The production metaphor: a clean PR that would pass review. Band 4: correct first pass, optimal algorithm, named helpers. Band 1: cannot produce working code in the allotted time.

4. Verification. Dry runs, test cases, debugging, edge-case probing. The production metaphor: you do not ship without a smoke test. Band 4: proactively tests empty / single / duplicate / large, traces code, finds own bugs. Band 1: declares “done” without testing.

code

1FOUR-AXIS HIRE RUBRIC (1–4 bands) — say the axis names aloud in mocks23  Axis                 Strong Hire (4)              No Hire (1)4  ------------------   --------------------------   -----------------------------5  Communication        drives the round; succinct   silent / chaotic / off-topic6  Problem Solving      clarify → decompose →        stuck, or random first idea7                       alternatives → use hints8  Technical / Coding   clean, correct, optimal      cannot produce working code9  Verification         dry-run + edges proactively  never tests; “looks fine”1011  Hire ≈ ≥3 on every axis. One axis at 1 → reject.12  Senior signal is narration + recovery, not code volume.

The six-step interview loop

Run this loop every time. Skipping a step is how builders fail “easy” problems. 1. Clarify — inputs, outputs, constraints, examples, edge cases, expected scale. 2. Approach — name the pattern or brute force first; discuss tradeoffs. 3. Complexity — state time and space before you commit to code. 4. Code — structured, named, with helpers if it keeps the main path readable. 5. Test — dry-run a small example; hit empty, single, duplicate, large. 6. Optimize — only if needed and time remains; name what improved.

Time-box mentally for a 45-minute round: ~5 min clarify + approach, ~3 min complexity and skeleton, ~25 min code, ~8 min test and polish, ~4 min buffer. Two-problem rounds (common at Google) force you to stop polishing problem 1 early. Saying “I am moving to verification so we have a complete first solution” is a senior time-management signal.

Company tiers: calibrate the bar, not the gossip

FAANG live coding (Google Docs / CoderPad): medium→hard, heavy weight on structured problem solving and verification. Google often 2 problems / round with no autocomplete — mental compile is the game. Meta stacks multiple live rounds; speed + fluency matter. India product OAs (HackerEarth / HackerRank at Flipkart, Razorpay, CRED, PhonePe, Swiggy): 60–90 min OA with 2–3 DSA questions, then 2–4 live medium-hard rounds. Speed on classic patterns is the filter; behavioral carries less weight than US senior loops.

AI-native labs (Anthropic, OpenAI): OAs still exist as gateways, but live rounds skew “build a small thing from scratch” — rate limiter, cache, concurrent structure — with stricter code-quality weight. Python fluency helps. Strong startups (Stripe, Datadog): domain-flavored medium problems; production thinking is graded alongside algorithms. Seed / YC: fewer rounds, often easier DSA, but expect to talk systems if senior.

Ten builder dings — name them so you stop committing them

1. Silent coding. 2. Jumping to a solution in the first 30 seconds. 3. No clarifying questions. 4. Brittle off-by-one / null-blind code. 5. No tradeoff discussion. 6. No manual dry-run. 7. Defensive collapse on hints (freeze instead of course-correct). 8. One-letter variables and copy-pasted blocks. 9. No complexity statement. 10. Declaring “done” without testing. Each of these is a scored axis, not a style preference.

The flip side — senior signals that hire: ask constraints before coding; state brute force then improve; name the data structure and why; write a test list before or right after coding; when stuck, narrate options rather than go quiet; when given a hint, restate it and continue. Interviewers are looking for a colleague they can debug with, not a compiler.

Two Sum as a rubric drill (not a solution to memorize)

Two Sum is the most cloned interview problem because it is a rubric microscope: trivial to brute force, one clean optimal pattern, rich clarifying surface, easy to botch verification. Use it to practice the loop, not to memorize indices. Prompt: given an array of integers nums and integer target, return indices of two numbers that add to target. Assume exactly one solution; you may not use the same element twice.

Clarify out loud: Are there negatives? Duplicates? Is the array sorted? Return any pair of indices or a specific one? What if no solution (you said exactly one — confirm)? Size of n? Brute force: O(n²) nested loops. Optimal: one pass hash map from value → index; for each x, look up target−x. Time O(n), space O(n). If sorted: two pointers O(n) time, O(1) space — different problem family (Two Sum II).

python

1TWO SUM — narrated optimal (hash map). Practice saying every comment aloud.23def two_sum(nums: list[int], target: int) -> list[int]:4    # Clarify: exactly one solution; may not reuse same index.5    seen: dict[int, int] = {}  # value -> index6    for i, x in enumerate(nums):7        need = target - x8        if need in seen:9            return [seen[need], i]10        seen[x] = i11    raise ValueError("no solution")  # contract violation if problem guarantees one1213# Dry-run: nums=[2,7,11,15], target=914# i=0 x=2 need=7 not seen -> seen={2:0}15# i=1 x=7 need=2 in seen -> return [0,1] ✓16# Edges: n=2 minimum; negatives; duplicates (2+2=4 with distinct indices).

Verification narration: “Empty array is out of contract if n≥2. Single element cannot pair. Duplicates: [3,3], target 6 must return different indices — the map overwrites index only after the check, so the first 3 is still findable. I will state complexity: O(n) time, O(n) space. If interviewer asks for O(1) space, I ask if sorted is allowed.” That paragraph is worth more on the rubric than the ten lines of code.

Two Sum — Explained (NeetCode)NeetCode

Interview prep — answers that sound senior

Foundations rounds and warm-up questions test whether you treat the interview as a scored collaboration. Pre-write these so a single rubric label maps to a ready explanation.

01“How do you approach a coding interview problem?” → clarify constraints → brute force → improve → state complexity → code → dry-run edges → optimize if time.
02“What do interviewers grade you on?” → four axes: Communication, Problem Solving, Technical Competency, Verification — hire needs solid marks on all four.
03“You went quiet for two minutes — what should you have done?” → narrate state: “checking X; if stuck at Y I’ll pivot to Z” — silence scores Communication 1.
04“Brute force first or optimal first?” → name brute force in 30 seconds, then improve; jumping to clever code without framing loses Problem Solving points.
05“How is an AI-lab round different from FAANG?” → more “build from scratch” + code quality; less pure puzzle; still needs the six-step loop.
06“Why say complexity before coding?” → commits you to a plan, invites course-correction early, and fills the Technical + Problem Solving axes with evidence.
07“What if you get a hint?” → restate it, integrate, continue — freeze is the builder collapse mode.
08“Done means?” → not “code compiles in my head” — means dry-run + edge list + complexity restated.

Follow-ups that separate blog readers from builders: “Walk me through Two Sum without writing code for three minutes” (pure Communication + Problem Solving); “Your first approach was O(n²) — what would you try next?” (recovery); “How would you test this if you had five minutes?” (Verification). Always lead with the axis the question is probing.

You are on call; the interviewer is your incident partner. Status updates, constraints, and a smoke test are not optional polish — they are the product under evaluation.

articleCoding Interview Rubrics — Tech Interview HandbookTech Interview Handbook articleGoogle Coding Interview Rubric — An Inside LookExponent article15 LeetCode PatternsAlgoMaster articleCoding interview study planTech Interview Handbook

Worked families + behavioral (same axes)

Family A — Restate and bound. Read twice; one-sentence restatement (public Meta/Google rubric write-ups correlate restating with higher hire rates because it proves listening); list inputs/outputs/constraints (size, order, duplicates, mutability); name naive complexity; pick the bottleneck and one optimization. Family B — Structure first. Map operations (lookup, ordered scan, min/max, range sum) to hash/heap/tree/sorted array/deque; write the algorithm on operations; derive complexity from the structure. Family C — Tradeoff table. List 2-3 approaches; tabulate time/space/code complexity/constants; pick with a reason tied to clarified n. This trio fills Communication + Problem Solving before any keystroke. When stuck mid-round, restart Family A out loud rather than freezing — recovery is graded.

Behavioral still scores Communication. Tell me about yourself: 60-90s role + domain + one shipped outcome + why this team. Walk a project: STAR-L ending on the lesson. Disagreement: person vs idea; update on evidence. Failure: what broke, process change, what you would still do differently. Three years: depth vs breadth on their ladder — never "your manager's job." Specificity beats charisma at L4+. Company-tier preview: FAANG live grades all four axes with committee quorum; India OA/SDE-1 collapses verification into hidden tests and weights speed; AI labs reweight problem definition, abstraction taste, and what you would monitor in prod. Prep the mix you applied to. The hire packet is a distributed system: independent interviewers write structured logs; committee is quorum. Make every log line easy to quote as Hire.

articleMeta Engineering — Get that job at FacebookMeta Engineering articleGoogle — technical interview tipsGoogle Careers

Checkpoint

You open a CoderPad, read “return indices of two numbers that sum to target,” and immediately start typing a nested loop. Interviewer has said nothing. Highest-leverage next 60 seconds?

AFinish the O(n²) solution silently, then optimize if time remainsBStop typing; ask about negatives, duplicates, array size, and whether exactly one solution is guaranteed; state brute force then hash-map plan with complexitiesCAsk whether you can use built-in sort and two pointers instead of discussing anything else

Checkpoint

After 20 minutes you have a mostly correct solution. Interviewer says “what about the empty array?” You freeze and go quiet for 40 seconds. What did the rubric just lose, and the recovery move?

ATechnical Competency only — recovery is to rewrite the whole functionBVerification and Communication — recovery is narrate: “empty is out of contract if n≥2; I’ll add a guard and dry-run [ ] / [x] / [a,b]”CProblem Solving only — recovery is to claim empty cannot happen so skip it

Checkpoint

You are targeting Anthropic L4 and Google L4 in the same month. How should prep differ?

AIdentical prep: 500 random LeetCode mediums for bothBGoogle: pattern-first live narration on Docs-style problems; Anthropic: add from-scratch structures (cache, rate limiter) and code-quality drills on top of patternsCSkip DSA for Anthropic; only do system design

Checkpoint

Which spoken line best signals Strong Hire on Problem Solving in the first five minutes?

A“I’ve seen this — the answer is a hash map.”B“Constraints first: n up to? negatives? Then brute force is O(n²); if n is 1e5 we need O(n). Hash map from value→index gives that; if input were sorted I’d use two pointers for O(1) space.”C“I’ll just code and explain later if it works.”

Checkpoint

You finished coding with 8 minutes left. Best use of the remaining time for the Verification axis?

AStart a second unrelated problem immediately to look fastBDry-run the happy path once in your head and say “looks good”CTrace a written example, then empty/single/duplicate/large; fix any bug found; restate complexity; only then offer a stretch follow-up

Could you run the six-step loop on a fresh easy/medium problem, narrate against the four axes, and self-grade Communication + Verification honestly?

New to itGetting thereConfident

Takeaways

Four axes: Communication, Problem Solving, Technical Competency, Verification — one axis at 1 rejects.
Six-step loop: clarify → approach → complexity → code → test → optimize; never skip clarify or test.
Biggest builder failure is silent coding; narration is the skill, code is the artifact.
Calibrate by tier: FAANG live DSA vs India OA speed vs AI-lab build-from-scratch quality.
Two Sum is a rubric drill — practice the spoken loop, not memorized indices.
Pattern-first 150–250 beats random 600+; Easy drills train axes before Hard loads cognition.

Next: two pointers on arrays and lists — opposite ends, same-direction, and fast/slow with production metaphors.

Sources

Free to read · better with Enzo

Learn it with Enzo

Save your progress, answer the checkpoints, and let Enzo quiz you on what you just read.

Continue with Enzo Sign up free