All AI interview guides

AI engineer interview guide

AI Engineer Roadmap for 2027

The short answer. The fastest route into AI engineering in 2027 is not a new degree; it is a portfolio of small systems you can explain, measure, and improve. This roadmap orders the work by interview value: retrieval and evaluation first, then agents and serving, with a capstone that shows a cost and latency budget. Treat the timing as a planning range, not a promise.

Updated 2026-11-05About 11 minutes to readReviewed against the LearningTo AI track

What should you learn first?

Build on the backend skills you already have: HTTP, data modeling, logging, testing, and one language you can write without friction. Then learn the model-facing layer: prompting, context windows, and tokens. Do not start with fine-tuning. Start with a tiny retrieval application that answers from a fixed document set and cites its source, because it forces you through the whole pipeline early.

Add an evaluation set before you add features. Ten to twenty realistic questions with expected evidence and a short rubric will teach you more than another tutorial. A rough planning range for this stage is three to four weeks at ten to fifteen hours a week, but the milestone is the working eval, not the calendar.

Which AI topics matter most for interviews?

Our AI track has 16 topics. For a first pass, six carry most of the interview weight: semantic search and document QA, prompting and context windows, evaluation and judge calibration, agents and stopping, inference economics, and guardrails. The remaining serving topics, including GPU selection, quantization, caching, and autoscaling, matter more for infrastructure roles and can come second.

Study in the order that matches the failure you can explain. Retrieval explains wrong answers, evaluation explains whether a change helped, agents explain tool loops, economics explains the bill, and guardrails explain the blast radius. When a topic has a practice page, do the graded challenge before reading the next chapter; the arithmetic is where the vocabulary becomes an answer.

What should you build?

Build three small systems, not one large one. First, a retrieval assistant with citations and an evaluation set, so you can discuss recall, packing, and grounding with evidence. Second, a tool-using agent with an allowlist, argument validation, a loop budget, and a written stop condition. Third, a serving or cost study where you measure latency and tokens per request and propose one optimization with a quality check.

If the interviews you want are platform roles, add a small MCP server. Expose two or three read-only tools over stdio, write a test that calls them, and document the capability list. That project lets you speak to the protocol in the MCP guide with first-hand detail instead of vocabulary.

How do you prove your work?

Every project gets a one-page write-up with the same five parts: the task, the baseline, the evaluation, the failure you found, and the change you made with the metric that moved. Link the code and show one bad output next to the fix. A reader should be able to check the claim without trusting you, which is exactly what an interviewer wants to do.

Keep a running table of latency and cost per request for each project. Numbers you measured on your own machine are honest and specific, and they give you something to say when the interviewer asks how you would budget. Do not invent market statistics to make a project sound important; the measured before and after is the stronger story.

How should you study each week?

Use a five-day loop. Read one topic page and its concept simulation, do the matching practice challenge, write the smallest implementation that demonstrates the idea, add or update an eval case, then explain the tradeoff out loud for two minutes. On the sixth day, review the failures from the week and pick the one you cannot yet explain. That gap is the next week plan.

A realistic rough range from this loop to interview-ready is ten to fourteen weeks at ten to fifteen hours a week, and it assumes you already write code comfortably. Shorten it by picking projects that reuse the same eval harness. Lengthen it without guilt if a serving topic needs more time. The plan is a tool, not a test.

What questions come up about an AI engineer roadmap?

1. How would you plan 90 days to prepare for AI engineer interviews?

Split it into three blocks. Weeks one to four: retrieval, prompting, and an evaluation set on one small project. Weeks five to eight: agents, guardrails, and a second project with a stop condition. Weeks nine to twelve: serving and cost, one system design rehearsal per week, and a written case study for each project. Leave the last week for mock interviews and repair, not new material.

Whether you can sequence learning around artifacts instead of topics alone.

2. What is the smallest portfolio project that signals competence?

A retrieval assistant over documents you know well, with citations, an evaluation set of ten to twenty cases, and a table of latency and cost. The small scope is the point: you can explain every stage, show a real failure, and prove the fix. Depth on one pipeline beats a tour of five demos.

That you optimize for evidence you can defend, not surface area.

3. Should I learn fine-tuning or RAG first?

RAG first. It teaches retrieval, evaluation, context budgets, and grounding, which appear in most AI product roles, and it does not require training infrastructure. Fine-tuning comes later, when you can name a behavior problem that prompting and retrieval do not fix and you can measure the result against the same eval.

That you learn the lever with the broadest interview surface first.

4. How much math do I need?

Enough to reason about scores, budgets, and rates: cosine similarity, precision and recall at k, a latency budget, token cost, and a cache hit rate. You do not need to derive a transformer. You do need to do arithmetic on a whiteboard and explain what each number means for the product.

That you can connect the math to a decision.

5. How do I show evaluation skill without a job?

Build the evaluation before the feature, keep the cases and the rubric in the repo, and write up where the judge disagreed with you. Interviewers can read a small, honest eval and see how you think. A claim like the system improved by 20 percent means nothing without the cases, the metric, and the sample.

That you can produce evidence on your own.

6. What should I read each week?

Read one primary source, one topic page in the AI track, and one postmortem or protocol specification. Take notes as answers to questions you would ask in an interview. Keep the reading list small enough that you finish it, because a finished small list beats a saved folder of links.

That your study habits produce explanations, not tabs.

7. How do I practice explaining tradeoffs?

Record a two-minute answer to one question from this guide, then listen for the constraint, the decision, and the failure you named. Rewrite it shorter and say it again. The goal is a defensible answer, not a memorized script; the interviewer will change one assumption and watch what you do.

That you rehearse the reasoning, not the wording.

8. What role does MCP play in a 2027 portfolio?

It is the clearest way to show that you can connect a model to tools and data through a standard protocol instead of a one-off integration. A small stdio server with two tools and a test demonstrates the lifecycle, capabilities, and error shapes that the MCP interview covers. Do not claim more than the specification supports.

That you can separate a protocol from an app feature.

9. What should I ignore?

Ignore framework churn, model leaderboards, and any roadmap that promises a timeline without a project. Learn the concepts that survive a release: retrieval, evaluation, grounding, latency, cost, and safety. The tools will change; the tradeoffs are what the interview keeps asking about.

That you can prioritize durable skills over news.

10. How do I know I am ready?

You are ready when you can take a new scenario, state the constraint, propose a baseline, name the evaluation, and describe two failures without notes. That is a higher bar than finishing a curriculum, and a better predictor than a checklist. Record one mock loop, review it, and fix the weakest layer before scheduling more.

That readiness is a behavior, not a count of finished lessons.

What mistakes show up in AI engineer roadmaps?

Collecting courses instead of building

A finished small project teaches more than a half-watched course. Every unit should end with something you ran, measured, and can explain, or it does not count as preparation.

Chasing frameworks before evaluation

The stack changes and the evaluation habit does not. Learn to build a test set and read a failure first; then any framework is a short step instead of a new identity.

No failure write-up

A portfolio that only shows successful demos is hard to trust. Write down the bad answer, the stage you found it in, and the change that fixed it. That is the part an interviewer can probe.

Ignoring cost and latency

An AI engineer is expected to know the bill and the wait. Put measured numbers next to each project, even if they are small and local. The habit is what matters in the design round.

Memorizing definitions

Definitions open the conversation; decisions carry it. For every term you learn, prepare one story about a failure or a tradeoff where the term did real work.

What else do people ask about the roadmap?

How long does this roadmap take?

A rough planning range is ten to fourteen weeks at ten to fifteen hours a week, assuming you already write code comfortably. That is an estimate for planning, not a measured outcome. The milestones matter more: a working retrieval project with an eval, an agent with a stop condition, and one serving study.

Do I need a CS degree?

No, but you need the fundamentals: data structures, HTTP, data modeling, testing, and enough statistics to read an evaluation. Interviews vary by company, and some loops screen those fundamentals directly. The portfolio can show product judgment, but it does not replace basic engineering fluency.

What changes in 2027?

Protocols such as MCP are maturing, evaluation expectations are rising, and cost and latency literacy is becoming a normal part of the role. The durable skills are the same: retrieval, evaluation, grounding, serving, and safety. Treat any specific tool forecast as a guess and plan around the concepts.

Which language should I use?

Python is the working default in the AI track on this site, and it is the safest choice for retrieval, evaluation, and serving experiments. TypeScript is useful if you build MCP servers or work on the host side. Pick one for the main projects and do not switch mid-plan.

What should I do this week?

Pick one topic, read its lesson, do the practice challenge, and add one evaluation case to a small project. Then write two paragraphs: what failed and what you changed. That loop is the roadmap in miniature, and repeating it is the plan.

Written by the LearningTo team. The week ranges are labelled planning estimates, and the project milestones map to lessons and practice pages that already exist in this repo.