Time Budget

Signals Interviewer Scores

• Problem-solving: did candidate reach optimal independently?
• Coding: clean, idiomatic, no bugs.
• Communication: think-aloud, asks vs. assumes.
• Verification: caught own bugs, tested edge cases.
• Speed: completed in time without rushing.

AI in the Loop (2026)

AI-use policy is company-specific and must be confirmed per round. Don't assume — the spectrum is real:

• Banned: any AI use is disqualifying (e.g. Amazon). Remote OAs are proctored.
• Allowed / disclosed: AI permitted, sometimes with adjusted rubrics; disclose if asked.
• AI-assisted round: using AI is the skill being tested (e.g. Meta's dedicated AI coding round, Shopify, Canva). You're given a larger codebase and asked to extend or debug it while prompting and verifying an AI assistant in the editor.
• Varies by team / interviewer: Google, Apple, Netflix, Microsoft — confirm before the round.

Proctored remote OAs commonly flag AI via copy/paste and tab-switch monitoring, screen-share requirements, keystroke/behavioral analytics, and similarity checks against known solutions.

Narration Phrases

• "Let me restate to make sure I understand: [problem]."
• "My initial thought is [brute force]. Let me check the complexity."
• "That's O(n²). Can we do better? Maybe [hint at structure]."
• "I'll use [data structure] because [reason]. Trade-off: [cost]."
• "Let me code the main loop, then handle edges."
• "Tracing: input X → state at line N is Y → output Z."
• "Edge cases: empty, single, duplicates, negatives, overflow."

Collaborative Posture

• Treat interviewer as pair-partner, not adversary.
• Ask permission to skip: "Should I implement helper X or assume it's given?"
• Acknowledge hints: "Good point — let me reconsider."
• Don't argue if interviewer disagrees; explore their view.

Checklist

• Input shape: type, range, sorted?, can be empty?, can have duplicates / negatives / unicode?
• Output: format, single answer or all, modify in place?
• Constraints: n size, time/space limits.
• Ambiguity: how to break ties, undefined cases.
• API surface: can I assume helper X exists? stdlib OK?
• Examples: walk through the given one. Construct one of your own.

For System Design

• Functional requirements: top 3 features only. Cut nice-to-haves.
• Scale: DAU, requests/sec, data size, growth.
• SLA: latency, availability targets.
• Reads vs writes ratio.
• Consistency requirements: strong vs eventual.
• Tenancy: single user, multi-tenant, geo.

Stuck Recovery

1. Pause & restate the subproblem aloud.
2. Try simpler input (n=1, n=2). Look for pattern.
3. List candidate techniques (DP? Greedy? Graph?). Cross out infeasible.
4. If still stuck after 3 min: "Let me ask — am I on the right track with [approach]?"
5. Accept hint gracefully. Explicitly integrate: "OK so with [hint] I can now..."

When to Abandon Approach

• Approach won't fit complexity target → switch fast.
• Edge cases require special-cases stacking up → wrong abstraction.
• Implementation requires obscure data structure → simpler exists.
• Sunk-cost fallacy is real. State explicitly: "I'm going to switch to [Y] because [reason]."

Top 15

1. Coding before clarifying.
2. Silent thinking > 30 sec.
3. Jumping to optimal without stating brute force.
4. Not stating complexity until asked.
5. Not testing before declaring done.
6. Off-by-one in loop bounds.
7. Mutating input then iterating it.
8. Ignoring edge cases (empty, n=1, duplicates).
9. Using global state in recursion.
10. Defensive code that hides bugs (try/except swallow).
11. Premature abstraction (helper for one-line op).
12. Variable names: x, y, tmp.
13. Copy-paste blocks instead of loops.
14. Not handling interviewer's hint as a hint.
15. Ending with "I think it works" instead of trace.

Flow

Rules

• Never just name-drop tech. State why Kafka vs SQS, Postgres vs Dynamo.
• Numbers always. "100M DAU, ~10 requests/day each = 1B req/day ≈ 12k avg WPS; ×3–5 peak factor ≈ 35–60k WPS peak."
• Draw flow before storage. Storage choice falls out of access pattern.
• Acknowledge trade-offs. No silver bullets.
• Drive the depth — tell interviewer what you'd dive into next.

Pacing

• If story past 4 min, you've lost interviewer. Self-monitor with mental clock.
• Pause for follow-up — interviewer will drill where they want depth.
• Don't pre-empt every angle; leave hooks for them to pull.
• Always end with explicit lesson: "What I'd do differently is..."

Follow-up Patterns

Week Before

• Confirm tech stack expectations with recruiter.
• Confirm the AI-use policy with your recruiter per round — allowed, disclosed, banned, or an AI-assisted round (policies are company-specific in 2026).
• Block prep: 4–6 hr/day.
• 2 mock coding rounds (Pramp / interviewing.io / friend).
• 1 mock system design.
• 1 mock behavioral.
• Re-read company eng blog (2 recent posts).
• Prep 3 questions per round.

Day Of

• Sleep 8 hr night before. Don't cram.
• Light meal pre-loop. Caffeine if normal for you.
• 15 min before: mental warmup — solve one easy problem out loud.
• Have water + paper + pen.
• Quiet, well-lit room. Camera at eye level.
• Test mic + screen-share before start.
• Between rounds: stand, water, reset. Don't dwell on perceived flubs.

After

• Within 24 hr: thank-you note to recruiter (not interviewers directly unless invited).
• Self-debrief: write down questions, what went well/poorly.
• If rejected: ask recruiter for feedback. Some give specifics.

Rules

• Never share current comp until offer in hand. "I'm looking for competitive total comp."
• Never accept on the call. "Thanks — let me review with my partner / take 24–48 hr."
• Always ask for a written offer document before negotiating.
• Negotiate on total comp (base + bonus + equity + sign-on), not just base.
• Use competing offers as leverage. If none, market data (levels.fyi).
• Ask for ranges, not points: "Is there flexibility on equity?"
• Recruiter is not your enemy — they want to close. Help them help you.

Levers

Annotated coding round: the two-parallel-worlds view

A transcript only teaches if you can see the candidate's words and the interviewer's private scorecard side by side. Below is a real-shaped 45-minute Meta E5 coding round on "merge k sorted lists". The left column is what the room heard; the middle is the interviewer's internal note; the right is the running signal (+ helps, − hurts). The verdict maps to Meta's four-point scale: strong no-hire / no-hire / hire / strong hire.

import heapq
def merge_k(lists):
    h = []
    for i, node in enumerate(lists):      # seed one head per list
        if node:
            heapq.heappush(h, (node.val, i, node))   # i = tie-break, never compares nodes
    dummy = tail = ListNode(0)
    while h:
        val, i, node = heapq.heappop(h)
        tail.next = node; tail = node
        if node.next:
            heapq.heappush(h, (node.next.val, i, node.next))
    return dummy.next
# n = total nodes, k = lists. Time O(n log k), space O(k).

Annotated system-design round: signals live in the tradeoffs

Design rounds are scored on how you drive, not whether you "know the answer." Here is an annotated senior (L5) Google round: "design a URL shortener at 10k writes/s, 100k reads/s, 5-year retention." Google scores each interviewer 1–4 (1 = strong no-hire, 4 = strong hire) and the hiring committee reads the written feedback, not just the number.

Leveling rubric: the L4 / L5 / L6 bar per axis

Interviewers don't grade "good/bad" — they grade against a level bar on fixed axes. The same transcript can be a strong hire at L4 and a no-hire at L6. Internalize the bars so you can pitch your narration at the target level: an L6 who only demonstrates L4 signals gets down-leveled or rejected.

Cross-company level mapping

Levels are not portable by number. Google L5 is senior; Meta E5 is senior; Amazon SDE III / L6 is senior. A recruiter quoting "we're leveling you at L5" means wildly different things at different companies, and it sets your comp band. Use this to translate before you negotiate.

Per-company loop structure

The same skills are scored, but the ceremony differs. Knowing the loop lets you allocate prep: Amazon rewards behavioral depth far more than the others; Meta compresses design into one high-stakes round; Google adds a committee layer that decouples "your interviewers liked you" from "you got the offer."

• Meta (E5) — Recruiter screen → 1 technical phone screen → onsite "loop" of 2 coding + 1 system design + 1 behavioral ("Jedi"). Design is a single 45-min round, so it's high-leverage. Feedback goes to a hiring manager, not a separate committee. Down-leveling to E4 is common rather than outright reject.
• Amazon (SDE II/III) — Online assessment (OA) → phone screen → onsite of 4–5 rounds, each anchored to Leadership Principles with a "Bar Raiser" (a trained, cross-org interviewer with veto). Expect ~50% of every round to be LP behavioral in STAR format even in coding rounds. The Bar Raiser's job is to reject candidates who'd merely match the current team's average.
• Google (L5) — Recruiter → phone screen → onsite of ~4 rounds (coding-heavy, 1 design at senior+). Interviewers write detailed feedback and score 1–4; a hiring committee that never met you decides, then team match, then a comp committee. This is why Google is slower and why "my interviewers loved me" doesn't guarantee an offer.

Platform & logistics mechanics

Tooling failures cost real signal — fumbling the editor reads as fumbling the problem. Know the surface before the round so your cognition goes to the algorithm, not the IDE.

• CoderPad (Meta, many startups) — collaborative editor with a run button; you can execute code and see stdout. Pick your language early; it has autocomplete off by default. Write and run your own test cases — running code that passes is a strong signal.
• HackerRank / CodeSignal (Amazon OA, screens) — auto-graded against hidden tests, often timed and proctored. Here correctness against edge cases is everything; there's no human to award partial credit for a clean approach. Read constraints for the intended complexity.
• Google's tooling — historically a shared Google Doc or a basic editor with no execution. You must dry-run by hand, so practice tracing code on paper. Syntax perfection matters less than a correct, self-verified trace.

Negotiation with 2026 comp anchors & scripts

Compensation is a range, and the recruiter's first number is the bottom of it. These are representative 2026 total-comp (TC) bands for US big-tech senior roles — treat them as anchors, not quotes, since bands shift with market and location. TC = base + annualized equity + bonus.

Three levers move the number, in order of power: a competing offer (largest), your current/target comp, and the level itself (up-leveling beats any dollar haggle within a level).

• Exploding offer — a deadline ("decide in 72 hours"). Deadlines are almost always soft. Script: "I'm genuinely excited and want to say yes to the right package. I have a final round elsewhere on the 14th — can we extend the deadline to the 16th so I can commit fully?"
• Competing offer — the strongest lever. Script: "I have a written offer at $X TC. Your team is my first choice; if you can get to $Y I'll sign today and stop interviewing."
• No competing offer — anchor on level and market. Script: "Based on my research the band for this level tops out higher than this. Given my scope, can we revisit the equity component specifically?"