The Complete AI Full-Stack Engineer Roadmap (Interactive)

The path at a glance#

The roadmap has nine stages. Each one builds on the stages before it, and each one ends with something you ship. Select a stage to open its section. As you mark articles complete, finished stages light up.

The order is deliberate. You cannot debug a streaming endpoint without understanding Node.js streams, you cannot build reliable RAG without SQL, and you cannot make an agent safe without understanding tool use. Skipping ahead feels fast for a week and slow for a month.

The skill tree#

The stages are groups of concrete skills. The tree below shows every skill and what it builds on: an arrow from Structured outputs to Tool use means tool use assumes you already know how to get schema-valid JSON out of a model. Select any skill to see what it covers.

Two things stand out when you look at the tree as a whole:

• Tool use is the hinge. Agent patterns, the agent loop, MCP, and security all depend on it. If you only master one LLM engineering skill deeply, make it this one.
• Evals feed everything in production. Cost optimization, model routing, and even your portfolio depend on being able to prove that a change made things better.

Stage by stage#

Each stage below lists what you learn, what you ship, and the exit criteria: the concrete things you should be able to do before moving on. If you can already meet a stage's exit criteria, skim it and move ahead.

1. Start Here (about 2 weeks on the standard plan)#

Understand the role, set up your environment, and pick a plan.

• Ship: a working practice project that calls the API from Node.js.
• Exit criteria: you can explain what an AI-powered full-stack engineer does in two sentences, and node --env-file=.env.local check-env.ts prints a model reply.

2. Foundations (about 4 weeks)#

TypeScript, Node.js, React and Next.js, PostgreSQL, APIs, and deployment.

• Ship: a small CRUD app with authentication and Postgres, deployed with CI.
• Exit criteria: you can explain the Node.js event loop, write an Express or Next.js endpoint with input validation, design a three-table schema with indexes, and deploy from a Git push.

3. LLM Fundamentals (about 2 weeks)#

How models work, how to choose one, and how to handle keys and billing.

• Ship: a cost estimate for an AI feature you want to build.
• Exit criteria: you can estimate the token count and cost of a request, explain why the API is stateless, and explain what happens when a conversation outgrows the context window.

4. LLM App Engineering (about 5 weeks)#

Chat, streaming, prompts, structured outputs, tool use, RAG, and caching.

• Ship: an AI chat app with streaming, and a docs Q&A app with RAG and citations.
• Exit criteria: you can stream a response into a React UI, get validated JSON out of a model, implement a tool-use loop, and explain why a retrieval answer was wrong by reading what was retrieved.

5. Agents & Orchestration (about 5 weeks)#

When to use agents, design patterns, multi-agent systems, MCP, durable execution, and human approval.

• Ship: a tool-using support agent and a custom MCP server.
• Exit criteria: you can argue for a workflow instead of an agent when it fits, cap and log an agent loop, and expose a capability as an MCP server.

6. Production AI Engineering (about 2 weeks)#

Evals, observability, reliability, security, and cost.

• Ship: evals and tracing added to an earlier project, with a regression test in CI.
• Exit criteria: you can show a trace for a bad answer, run an eval suite before a prompt change, and name three defenses against prompt injection.

7. AI-Assisted Development (about 1 week)#

Working with coding agents to build, review, test, and debug.

• Ship: a feature built with a coding agent, with tests you wrote first.
• Exit criteria: you can give a coding agent a task specification that produces a reviewable change on the first try.

8. Projects (about 3 weeks for the capstone)#

Six builds of increasing difficulty; the earlier ones happen inside stages 4 and 5.

• Ship: the capstone, a production SaaS AI assistant with auth, RAG, tools, evals, and tracing.
• Exit criteria: a stranger can sign up, use it, and you can tell them what it costs per conversation.

9. Career (about 2 weeks)#

Portfolio, writing, interviews, and staying current.

• Ship: a portfolio page, two write-ups, and practice answers to AI system design questions.
• Exit criteria: you can walk an interviewer through one project's architecture, trade-offs, and failure modes in ten minutes.

Timelines: 3, 6, or 12 months#

The same path stretched or compressed to fit where you start. Switch plans to compare them; durations are in weeks.

Your first proof of skill#

The fastest way to make the roadmap real is to ship the stage 1 deliverable today. This command-line program asks a model for a study plan for one stage, using what you know as context. It uses everything from your environment setup: ES modules, top-level await, and the Anthropic SDK.

import Anthropic from "@anthropic-ai/sdk";
 
const [stage = "LLM App Engineering", ...known] = process.argv.slice(2);
const client = new Anthropic();
 
const message = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  output_config: { effort: "low" },
  system:
    "You are a pragmatic mentor for web developers learning AI engineering. " +
    "Answer with a 5-item checklist of concrete practice tasks, each doable in one evening.",
  messages: [
    {
      role: "user",
      content: `Stage: ${stage}. What I already know: ${known.join(", ") || "nothing yet"}.`,
    },
  ],
});
 
for (const block of message.content) {
  if (block.type === "text") console.log(block.text);
}

node --env-file=.env.local plan.ts "LLM App Engineering" TypeScript React

Notice what the program does not do: it does not remember the last plan it gave you, it does not know which articles you read, and it cannot check its own advice. Stage 4 teaches multi-turn memory and structured output; stage 6 teaches you to measure whether advice like this is any good.

Common mistakes#

• Starting with agents. Agents combine every skill before them. Without tool use, structured outputs, and tracing, an agent bug looks like random model behavior.
• Treating the timeline as a race. Stretching a stage is fine. Skipping its project is not.
• Collecting certificates instead of shipping. Interviewers ask what you built, what broke, and what it cost. Projects answer all three.
• Ignoring foundations because "the AI writes the code." Coding agents make strong engineers faster; they do not make up for missing judgment about data models, security, or failure modes.

Next steps#