Dashboard
Your 13-week run to a big tech AI Engineer offer. ~1.5–2 hrs/day, 5 days/week. Check off tasks as you go — progress saves in this browser.
Coverage gaps
Not yet covered in this pass: Apple, xAI, Databricks, and smaller labs (Cognition, Cursor, Sierra, Mistral). If any become a target, they'll get a pipeline page here too.
Meta — ML Engineer / AI Engineer (E4–E7)
Close to a pure SWE loop for coding; offers at E5+ are won in ML system design and behavioral scope.
The loop
Recruiter call or async questionnaire — background, motivation, leveling.
Two medium DSA problems. Standard LeetCode mediums from a recurring pool.
Coding ×1–2, one AI-assisted coding round (60 min — debug/extend a real codebase with an LLM; replaces one traditional coding round in some loops), ML system design, behavioral.
What they grade
- Coding bar ≈ pure SWE loop. Meta expects AI engineers to be strong software engineers first. reported
- ML system design decides offers at E5+: end-to-end pipelines, ranking/recsys framing, metrics tied to business outcomes (engagement, revenue, integrity coverage) — not academic ML answers. reported
- Behavioral is a real signal round, scored against five axes: resolving conflict, growing continuously, embracing ambiguity, driving results, communicating effectively. official
- Leveling (E4–E7) is decided largely from scope shown in behavioral + design answers. reported
Prep notes
- DSA up to medium-hard from the recurring pool
- ML system design at billions-of-users scale; recommendation/ranking systems
- Llama / PyTorch ecosystem familiarity
- Practice the AI-assisted format: directing and verifying an LLM, not typing speed (see AI-assisted rounds)
Sources
- https://www.tryexponent.com/guides/meta-machine-learning-engineer-interview
- https://www.prepfully.com/interview-guides/meta-machine-learning-engineer
- https://github.com/garliatsai/ai-engineering-interview-questions-company-wise
- https://github.com/ombharatiya/ai-engineer-interview-questions/blob/HEAD/14-company-interview-questions/meta-ai.md
OpenAI — SWE / MLE / Applied AI Engineer
Practical engineering over algorithm puzzles. A genuine point of view on AI threads the entire loop.
The loop
Brief; screens motivation + AI fluency: your background, why OpenAI, where AI is headed.
One coding (practical, not LeetCode: build-something-real tasks, e.g. in-memory KV store with transactions, small database ORM, file-system traversal) and one system design (obsessed with scale: "how does this hold up at 100x/1000x load").
Coding, system design, project presentation (what you personally built), 1–2 behavioral/mission-fit rounds. Some pipelines include a HackerRank-style OA or a take-home project (4–8 hrs, evaluated on code quality + design + thoughtfulness).
What they grade
- Practical engineering over puzzles: completeness first, then optimize; accuracy and edge-case handling over raw speed. reported
- A genuine POV on AI threads the whole loop, recruiter call to final behavioral. Be ready to discuss ethics/safety in AI; read the OpenAI blog. reported
- Reported offer rate ~3% across 205 reported interviews — candidate-reported aggregate, treat as directional only. reported
- Recruiters give detailed prep tips before some rounds — take them seriously. reported
- Reputation for downleveling candidates; team matching happens after the offer. reported
Prep notes
- Practical system building (KV store, ORM, schedulers) over LeetCode grinding
- Information theory / probability refresh (research-eng tracks)
- Project deep-dive slides: what you personally built, decisions, trade-offs
- Mission-alignment narrative with a real point of view
Sources
- https://www.aced.io/guides/openai-software-engineer-interview
- https://dataford.io/interview-guides/openai/software-engineer
- https://www.tryexponent.com/blog/openai-interview-process
- https://www.tryexponent.com/guides/openai-software-engineer-interview-guide
- https://interviewing.io/openai-interview-questions
Google — AI / Machine Learning Engineer (L4/L5)
"ML breadth" is the bar: pivot from transformer architecture to data-pipeline optimization. System design is the biggest filter.
The loop
Background, role fit, leveling.
LeetCode medium/hard, ML-adjacent data structures.
Coding ×2 (AI-assisted as of May 2026 in some loops), ML depth/breadth ×1–2 (one deep dive, e.g. attention mechanisms; one broad ML survey), ML system design (large-scale AI systems, e.g. Gemini-scale serving), Googleyness & Leadership (behavioral). Team matching increasingly happens early for AI roles.
What they grade
- "ML breadth" — ability to pivot from transformer architecture to data-pipeline optimization. Hiring bar exceptionally high here. reported
- System design is the biggest filter per candidate reports: must architect an end-to-end production pipeline with serving infrastructure at scale, not just describe training a model. reported
- If AI tools are allowed in coding rounds, the bar shifts to architectural reasoning — "if you can't explain the AI-generated code, you're rejected on the spot" (unofficial aggregation). reported
- Googleyness: culture-fit behavioral round, standard for Google. reported
Prep notes
- LeetCode medium/hard
- MHA / transformer implementation from scratch (reported question: "implement a MHA class")
- Loss functions and model trade-offs
- Production ML pipeline design; Gemini / TPU / serving familiarity
Sources
- https://github.com/landedjobs/ai-interview-guides/blob/HEAD/guides/google.md
- Glassdoor candidate reports (Jul 2026, Mountain View)
- https://www.tryexponent.com (May 2026: Gemini AI-assisted code-comprehension pilot)
Anthropic — SWE / MLE / Applied AI Engineer
The values/mission round is the biggest filter — candidates report it fails more people than the technicals.
The loop
Substantive "Why Anthropic?" (200–400 words) — carries real weight.
Substantive and failable — not a formality.
CodeSignal-style or live coding: one practical problem in ~4 progressive levels.
Coding (practical build-and-extend, e.g. in-memory DB with TTL, task scheduler), system design (distributed systems, AI-infra flavored), values/mission round, project deep-dive. Applied AI loops add LLM-implementation and customer-facing rounds. Hard gate after technicals — later rounds get cancelled if coding/system design aren't cleared. End-to-end: 3 weeks to ~2 months.
What they grade
- Values/mission round is the biggest filter. Expect AI-safety reasoning, intellectual honesty, nuanced thinking: "Why Anthropic?", "where do you disagree with Anthropic?", views on AI safety/risks. reported
- Coding is practical, not LeetCode: clean, tested, readable code as if for code review; incremental problems layering constraints, edge cases, scale. reported
- "We care about what you can do, not where you learned to do it" — about half of technical staff had no prior ML experience. official
- Independent research, blog posts, open source go at the top of the resume. official
- AI policy: permitted on the take-home, banned in live rounds; some MLE loops add an AI-collaboration round where Claude is provided and you're graded on directing/verifying it. reported
Prep notes
- Python fluency (shared Python environment)
- System design for LLM serving infra
- A real, personal answer to "why Anthropic" grounded in their safety work and products (Claude.ai, API behavior)
Sources
- https://www.designgurus.io/blog/anthropic-interview-process
- https://spacecomplexity.ai/blog/anthropic-onsite-interview
- https://github.com/schuture/anthropic-interview-notes/blob/HEAD/PROCESS.md
- https://leetcodewizard.io/blog/mastering-the-anthropic-software-engineer-interview-questions-process-and-expert-tips-for-preparation
Amazon — ML Engineer / Applied Scientist (AWS / AGI)
The 16 Leadership Principles are the behavioral backbone — know them cold. Every round includes LP questions.
The loop
Background, role fit, compensation expectations.
Coding + ML basics.
Two coding, one ML breadth, one ML depth / research deep-dive or ML system design, one bar-raiser. Every round is anchored on Leadership Principles. Applied Scientist loops add a research presentation.
What they grade
- The 16 Leadership Principles — know them cold; every round includes LP questions ("Tell me about a time…"). official
- Bar-raiser assesses holistic fit beyond the specific team. reported
- Technical: coding (standard DSA), ML fundamentals (bias–variance, regularization, optimization), modeling choices and experimentation judgment, production ML issues. reported
- "Customer obsession applied to AI"; bias for action over perfection; frugality in model serving. reported
- No AI-assisted round reported. reported
Prep notes
- 16 LPs with a STAR story for each — this is the highest-ROI prep for Amazon
- Bedrock / SageMaker / Alexa architecture familiarity
- Recommendation systems; NLP at scale
Sources
- https://prachub.com/interview-guide/amazon-machine-learning-engineer-interview-guide
- https://github.com/garliatsai/ai-engineering-interview-questions-company-wise
- https://github.com/johnnnmai/awesome-ai-engineer-interview
Microsoft — AI Engineer (Azure AI / Copilot / CoreAI)
DSA still gates everything — classic data-structures problems even at senior loops. Growth mindset is graded, not decoration.
The loop
Mix of behavioral + technical.
Coding + ML fundamentals; some loops have a hands-on round like implementing a RAG pipeline with Azure OpenAI.
Two coding (LeetCode-style even for AI teams — unlike frontier labs), one ML/AI depth, one AI system design or low-level design (e.g. the tool-calling layer of an agent host spanning native code, OpenAPI specs, MCP servers), and an as-appropriate (AA) round with a senior leader. Azure AI / Copilot roles add a customer-architecture round.
What they grade
- DSA gates everything — classic data-structures problems even at senior/principal loops (reported, varies by team). reported
- Growth mindset is graded: six competencies — collaboration, drive for results, customer focus, influencing for impact, judgment, adaptability — with STAR(R) stories (extra R = Reflection). "Learn-it-all over know-it-all." official
- Enterprise constraints are the home-field advantage: design rounds reward reflexively handling tenancy, permissions/ACL trimming, compliance, and cost at hundreds-of-millions-of-users scale (Copilot reality). reported
- Three AI orgs, three flavors: CoreAI (platform: Azure AI Foundry, agent stack), Microsoft AI / MAI (consumer Copilot, in-house models), product Copilot teams (M365 / Dynamics / Security). GitHub hires separately. reported
Prep notes
- LeetCode mediums — don't skip these for "AI teams"
- RAG / retrieval; agents and tool use (MCP, function calling)
- Inference cost/latency reasoning (p95 first-token budgets, 10x cost-cut exercises)
- Enterprise architecture: multi-tenancy, ACLs
Sources
- https://www.tryexponent.com/guides/microsoft-machine-learning-engineer-interview
- https://github.com/ombharatiya/ai-engineer-interview-questions/blob/HEAD/14-company-interview-questions/microsoft.md
- https://github.com/sakhawathossen04/ai-engineering/blob/HEAD/interview/01-interview-process.md
- https://www.datainterview.com/blog/microsoft-ai-engineer-interview
NVIDIA — Deep Learning / LLM Performance SWE
Hardware–software co-design thinking. Live CUDA coding and "diagnose this slow kernel without running it."
The loop
Background, role fit.
Technical screen with the hiring manager.
CUDA/C++ or Python coding, GPU performance and roofline reasoning, LLM inference depth, ML fundamentals, system/solution design. DevTech-style tracks can be heavier: pre-screen → take-home CUDA assignments (real profiling/optimization with Nsight) → 2 screening rounds → 6-interview onsite across 2 days → hiring-manager round. Timeline: several weeks to 6–8 weeks.
What they grade
- Deep GPU architecture, CUDA programming, model optimization; hardware–software co-design thinking. reported
- Inference optimization (TensorRT, Triton); paged KV-cache design; mixed-precision debugging; parallelism strategies (tensor / pipeline / data). reported
- Live CUDA coding; performance analysis ("here's a kernel 10x slower than expected — diagnose without running it"). reported
- Solutions Architect loops replace kernel depth with customer-scenario rounds. reported
Prep notes
- GPU memory hierarchy; CUDA kernels; roofline model
- TensorRT-LLM / Triton; Nsight Systems / Compute
- LLM inference internals: prefill vs decode, KV cache, quantization
Sources
- https://medium.com/@nakulsharma1322/how-i-cracked-the-nvidia-developer-technology-engineer-interview-a-complete-preparation-guide-c336804463ca
- https://igotanoffer.com/en/advice/nvidia-software-engineer-interview
- https://dataford.io/interview-guides/nvidia/software-engineer
- https://github.com/xiaojunzhao/ai-engineering-interview-questions-company-wise
Coding & DSA
The baseline hasn't moved: LeetCode medium-hard fluency. What's new is how some companies test it — practical builds and AI-assisted rounds.
The baseline
- LeetCode medium-hard is the baseline across Meta, Google, Microsoft, Amazon. Meta's screen is two mediums in 45 minutes; Google's phone screen is medium/hard. reported
- Meta draws from a recurring pool of standard mediums — pattern recognition beats novelty. reported
- Microsoft asks LeetCode-style questions even for AI teams — don't skip DSA because you're targeting AI roles. reported
Practical build tasks (frontier-lab style)
OpenAI and Anthropic test build-something-real over puzzles. Practice these until they're boring:
In-memory KV store
With transactions (OpenAI's reported example). Then extend: TTL expiry, persistence sketch. reported
Task scheduler
Priorities, delays, cancellation (Anthropic's reported example). reported
Small database ORM
Reported OpenAI example — mapping, queries, edge cases. reported
File-system traversal
Reported OpenAI example — recursion, symlinks, large trees. reported
Grading emphasis: completeness first, then optimize; accuracy and edge-case handling over raw speed; clean, tested, readable code as if for code review; incremental problems that layer constraints. reported
How to practice
- Timed sets: 3 mediums in 90 minutes, out loud, no pausing — matches screen conditions
- System-y coding: LRU cache, rate limiter, TTL cache — bridges DSA and system design
- Explain every line: in AI-assisted rounds you must narrate AI-generated code as your own reasoning
- Your edge: 5+ years including DevOps — lean into operational thinking (failure modes, observability) in build tasks; most candidates can't
AI-assisted coding rounds — the 2026 format change
The single biggest format change of the last year: several companies now run coding rounds with an LLM assistant — and grade you on how well you direct and verify it, not typing speed.
Per-company policies
AI-enabled coding round (CoderPad-style, ~60 min, choice of LLM assistants). Reportedly expanded through 2026 across SWE/EM loops up to E7/M2, paired with one classic AI-free coding round. Graded on how well the candidate directs and verifies AI. Candidates report the in-round assistant is deliberately less helpful than practice environments.
Piloted an AI-assisted code-comprehension round with Gemini (May 2026, per TryExponent) — while simultaneously bringing back an in-person round to curb cheating.
Added an agentic coding round in beta — the only live round where AI is allowed (the take-home also permits it for Applied AI roles).
Split policy: AI permitted on the take-home, banned in live rounds; some MLE loops include an AI-collaboration round where Claude is provided and you're graded on directing/verifying it.
ByteDance and Palantir explicitly ban AI use. Amazon and Apple report no AI round at all.
Prompt strategy
- Guide with your own hypotheses — don't ask for wholesale solutions. State your plan, then use the assistant for acceleration.
- Decompose before prompting: ask for the piece you need, keep architecture decisions yours.
- If the assistant's output surprises you, interrogate it — that's the skill being graded.
Verification discipline
- Test before trusting output. Write the test yourself; make the assistant earn it.
- Be able to explain every line as if you wrote it — "the AI wrote it" is not an answer.
- Practice with a weaker assistant than you're used to — the in-round one is reportedly less helpful than your daily tools.
- Narrate trade-offs out loud: why this approach, what you rejected, edge cases you're covering.
Sources
- https://github.com/ishanraychaudhuri2025/faang-coding-interview
- https://github.com/ombharatiya/ai-engineer-interview-questions/blob/HEAD/14-company-interview-questions/meta-ai.md
- https://www.tryexponent.com/guides/meta-machine-learning-engineer-interview
ML system design
Where offers are won at senior levels. Interviewers want end-to-end production thinking — not "here's how I'd train a model."
The end-to-end pipeline
Every ML system design answer should walk this spine, then go deep where the interviewer probes:
Data sources, labeling, pipelines, feature stores; training infra, experiment tracking, eval gates before deploy.
Offline vs online metrics, calibration, A/B design for ML. No eval story = no hire signal.
Serving infrastructure at scale: latency budgets (p95 first-token), batching, caching, quantization, cost-per-token. For LLM systems: prefill vs decode, KV cache, paged attention.
Drift, feedback loops, incident response, rollback. Production ML issues are explicitly graded (Amazon). reported
Recsys / ranking framing
- Meta's ML system design rewards ranking/recsys framing with metrics tied to business outcomes — engagement, revenue, integrity coverage — not academic ML answers. reported
- Practice: candidate generation → ranking → re-ranking; feature engineering; online learning; exploration/exploitation.
Scale reasoning
- OpenAI's obsession: "how does this hold up at 100x/1000x load?" — practice answering every design with an explicit scaling story. reported
- Meta: design at billions-of-users scale. reported
- Microsoft: enterprise constraints as reflex — tenancy, permissions/ACL trimming, compliance, cost at hundreds-of-millions-of-users scale. reported
- Google: architect the full production pipeline with serving infrastructure, not just training. reported
Drills
- Design an LLM serving system (latency, cost, batching, cache)
- Design a ranking system (candidates → ranking → business metrics)
- Take any design and do the 10x cost-cut exercise: same quality, one-tenth the inference budget
- For each design, name the first thing that breaks at 10x scale
AI topics
The nine cross-company AI modules that earn their place — distilled from what the seven pipelines actually grade.
1. LLM internals
Transformers, attention (implement multi-head attention from scratch — a reported Google question), positional encodings, pre-training vs post-training.
2. Inference & serving performance
KV cache / paged attention, quantization, TensorRT / vLLM, prefill vs decode, first-token latency, cost-per-token reasoning. This is NVIDIA's home turf and interviewers everywhere probe it.
3. RAG & retrieval
Chunking, embeddings, hybrid search (dense + BM25), eval of retrieval quality. Microsoft has run hands-on "implement a RAG pipeline" rounds. reported
4. Agents & tool use
Agent loops, function calling, MCP (Model Context Protocol), eval of agents. Microsoft's low-level design example: the tool-calling layer of an agent host spanning native code, OpenAPI specs, MCP servers. reported
5. Fine-tuning & alignment
SFT, RLHF / DPO, eval harnesses. Enough depth to discuss trade-offs, not just acronyms.
6. Evals & observability
Offline vs online metrics, calibration, A/B design for ML. Weak eval thinking is a quiet killer in system design rounds.
7. AI system design
End-to-end production ML pipelines (data → training → eval → serving → monitoring), recsys/ranking framing, scale reasoning (100x/1000x). See the ML system design module.
8. DSA / coding
LeetCode medium-hard baseline; practical build tasks (KV store, schedulers, crawlers); the new AI-assisted round format. See Coding & DSA and AI-assisted rounds.
9. Behavioral — 2026 formats
Meta's 5 axes, Amazon's 16 LPs, Microsoft's 6 competencies + STAR(R), Anthropic's values round (AI safety reasoning), OpenAI's mission-alignment thread. See Behavioral.
Study approach
- Implement, don't just read: MHA from scratch, a KV cache, a RAG pipeline, an agent loop. Interviewers probe implementation depth.
- One level deeper than comfortable on your weakest two topics — that's where loops are lost.
- For each topic, prepare a 2-minute explanation and a trade-off discussion (e.g. quantization: quality vs cost vs latency).
Behavioral
Behavioral rounds are scored, leveled, and failable — not a formality. Each company has its own framework. Map your stories to their rubric.
Frameworks
STAR — the base format
Situation, Task, Action, Result. Keep it tight: 2–3 minutes, result quantified. Microsoft uses STAR(R) — the extra R is Reflection: what you'd do differently. official
Meta — 5 axes official
Resolving conflict, growing continuously, embracing ambiguity, driving results, communicating effectively. Leveling (E4–E7) is decided largely from scope in these answers. reported
Amazon — 16 Leadership Principles official
The behavioral backbone: every round includes LP questions. Highest-ROI prep for Amazon is one STAR story per principle. The bar-raiser assesses holistic fit beyond the team.
Microsoft — 6 competencies official
Collaboration, drive for results, customer focus, influencing for impact, judgment, adaptability — told as STAR(R) stories. "Learn-it-all over know-it-all."
Anthropic — values / mission round reported
Reported to fail more candidates than the technicals. Expect AI-safety reasoning and intellectual honesty: "Why Anthropic?", "where do you disagree with Anthropic?", your views on AI safety and risks. Prepare a real, personal answer — not a press release.
OpenAI — mission-alignment thread reported
A genuine point of view on AI threads the whole loop, from recruiter screen to final behavioral. Be ready to discuss ethics/safety; read the OpenAI blog.
Google — Googleyness & Leadership reported
Culture-fit behavioral round, standard for Google.
Build your story bank
- 6 core stories covering: conflict, ambiguity, failure/mistake, leadership without authority, tight deadline, technical disagreement
- Each story: quantified result (latency cut, cost saved, users impacted, revenue)
- Map each story to Meta's 5 axes and Amazon's 16 LPs — one bank, multiple rubrics
- Add the Reflection beat to every story (Microsoft's STAR(R))
- Write your "why this company" narrative per target — grounded in their actual work, not generic praise
- Rehearse out loud, 2–3 minutes each, no rambling
Resume workbench
Paste your resume and a target job description below — they're saved in this browser only. Personalized tailoring activates once you add your resume.
Your resume
Target job description
Tailoring checklist
- Quantify impact in every bullet — metrics tied to business outcomes (this is what Meta grades in design and behavioral) reported
- Mirror the JD's keywords honestly — same vocabulary, no invented experience
- Lead with independent research, blog posts, open source — Anthropic puts these at the top of the resume official
- Make project ownership explicit: what you personally built, decided, and shipped — OpenAI's onsite includes a project deep-dive on exactly this reported
- One page per ~10 years is plenty; cut older roles to one line
- DevOps edge up front: deployment, infra, reliability, cost/latency work — the rarest signal in the AI applicant pool
- Skills section matches the target company's stack (PyTorch/Llama for Meta, Azure/AI Foundry for Microsoft, CUDA/Triton for NVIDIA…)
- No typos, no walls of text — 3–5 bullets per role, action verb first
Per-company resume signals
- Anthropic: the written application ("Why Anthropic?", 200–400 words) carries real weight — draft it with the same care as the resume. reported
- OpenAI: your resume must survive a deep-dive on any project listed — only list what you can defend for 30 minutes. reported
- Amazon: resume bullets should already hint at LP stories — you'll be asked "tell me about a time" for what's on the page. reported
Portfolio & GitHub
The market formula for AI Engineer portfolios: live demos + eval numbers + cost/latency figures. Interviewers and hiring managers skim — make the signal impossible to miss.
The three milestone projects
1. Production RAG chatbot
Deployed, not a notebook. Show: retrieval eval numbers, chunking choices, latency (p95 first-token), cost per query. This is directly interview-relevant — Microsoft has run hands-on RAG rounds. reported
2. Autonomous agent
Tool-calling agent with MCP. Show: eval harness results, failure-mode analysis, traces. Mirrors the agent/tool-use topic every lab now probes.
3. Production deployment
Your DevOps edge, weaponized: infra-as-code, CI/CD, monitoring, cost dashboards. Most AI applicants can't do this — it's your rarest signal.
Portfolio rules
- Live demo link on every project — dead projects don't convert
- Eval numbers, not adjectives: accuracy, latency, cost — the same metrics interviewers grade in system design
- READMEs that explain decisions and trade-offs — this is what a deep-dive round (OpenAI, Anthropic) will walk through reported
- Blog posts / independent research at the top — Anthropic explicitly values these on resumes official
- Pin the 3 milestone repos; archive or privatize tutorial forks
- One-line "what it is" + one-line "why it matters" per repo
What to skip
- Tutorial clones with no modification — they dilute the signal
- Private repos you can't show — they don't exist to a hiring manager
- Over-polished personal sites with no substance behind them