AI FDE: The Forward Deployed Engineer & Agentic AI Architect

,
, , , , ,
FDE Course

The Forward Deployed Engineer is one of the hottest jobs in AI right now, with postings up 1,000% this year, salaries reaching $400,000 and an estimated 30,000 openings across AI Architecture, FDE and related AI roles.

This course is your complete 3 week roadmap to becoming an FDE.

Making this course was a total guilty pleasure for me. I loved every minute of it, and I hope you enjoy it just as much! I took all the juiciest topics in AI right now and crammed them into 3 satisfying weeks of content, labs and projects.

This page has the extra resources: the links and additional notes for each day. Please keep it to hand as you take the course. If anything is missing, please message me on Udemy or at ed@edwarddonner.com and I’ll fix it up.

Major links

And please connect or follow me on LinkedIn and subscribe on YouTube. I don’t always see LinkedIn messages, so for questions please use Udemy or email.

Labs, branches and sharing your work

  • The labs for each day are in the repo’s labs folder. Most have a free version, with a name ending in free, that runs on free models.
  • From Week 1 Day 3, each day lists its branches under Branches. A day with a product build has a branch to start the build where I start, like week2day3-start, and one with my finished build, like week2day3-end. After git checkout, run npm install, and use the branch’s backend, dashboard and agent together. If Git complains about local changes, run git stash and try again.
  • I’d love it if you considered sharing your work as a pull request to community_contributions. My guide to making a PR is at edwarddonner.com/pr. If you’d be willing to post about it on LinkedIn and tag me, then I’ll weigh in to amplify your achievement.

Costs

  • The typical experience is around $10 of API spend, all in, as credit on OpenRouter. There are free alternatives throughout, though you may need more patience with free models. If you have the budget, $20 or more gets you production infrastructure and more test data.
  • From Week 1 Day 3, Claude Code needs a Claude Pro plan or API credit, and OpenCode with OpenCode Zen is the free alternative. Alternatively, there are instructions to ‘git checkout’ at each point to use the code that I generate, avoiding any Coding Agent costs. The AWS route in Week 3 needs an AWS account with a card, and Render is the free alternative.
  • Free models on OpenRouter are limited to 50 requests a day. Once you’ve bought $10 of credit, the limit goes up to 1,000 requests a day. The details are in OpenRouter’s docs.

Something different with this course

For this course I’ve added some quizzes, an AI role play, and PDF handouts at the end of the weeks. I’m hoping this will mix things up a little, but let me know if you find it a distraction.

Week 1: Become an AI Engineer

Week 1 Day 1: Path to FDE

  • The Google Colab for the instant gratification
  • The maze from the instant gratification. Your agent will probably take a different route from mine. Free models sometimes get lost or give up, and if that happens, just run it again.
  • OpenRouter: your API keys, and the privacy settings with the switches for free models. Those switches allow providers that may train on your prompts or publish them, so never send free models anything private or confidential.
  • Edit: I say that 48% of the job ads needed at least four of the five areas. The slide has it right: 48% required four of the five areas, and another 41% required all five. Together, 89% required at least four.

Week 1 Day 2: Frontier LLMs & Agents

  • Artificial Analysis compares models on intelligence, speed and cost. Bookmark it! The charts will have moved on since I recorded.
  • METR’s time horizons
  • Anthropic’s Building Effective Agents, a great read on agents and workflows
  • LangChain’s guide to agents and create_agent, and OpenRouter’s guides to structured outputs and prompt caching. Following up on my guess about Gemini and prompt caching: the caching guide says Gemini 2.5 models and newer cache automatically, with no setup needed.
  • Jev is on OpenRouter as typesafe/jev-1.13, and my YouTube video on it is Is Jev Really Better, Faster and Cheaper? I Put Jev To Test vs. Luna.
  • Edit: I say the minimum top-up on OpenRouter is $2. OpenRouter’s terms give a minimum purchase of $5, so check the amount at checkout.
  • Edit: I say there are six claim types. The chart shows seven.
  • Edit: I muddle up some comparisons! Gemini 3.5 Flash Lite cost almost 10 times as much as GPT-6 Luna at low, not more than 10 times, and it got 14 routine claims right. Jev cost less than Luna at low in that run: the totals for the whole queue were $0.0042 for Luna at low, $0.0318 for Gemini and $0.0033 for Jev.

My original video playlist from a year back on how ‘parameters’ make LLMs do what they do – people often ask me this.

Week 1 Day 3: Coding Agents & ADLC

An extra video on how to set up OpenCode + OpenCode Zen for free coding agents:

  • Branches: the build starts from main. For my finished pilot, git checkout week1day3-end.
  • Andrej Karpathy’s post that coined vibe coding, and his later post on coding agents as a powerful tool that came with no manual
  • OpenCode and OpenCode Zen, and my YouTube video on setting up OpenCode with free models. Zen’s free models may use your data for training, so never send them anything private or confidential.
  • Pi, the lightweight open-source coding agent I mention
  • Claude Code’s docs on AGENTS.md and CLAUDE.md, permission modes and MCP. There’s more on AGENTS.md at agents.md, and here’s the Playwright MCP server.
  • My YouTube video on the ADLC, and GitHub Spec Kit, one of the approaches to building code with agents
  • For much stronger controls, including a Claude Code hook that lints before Claude finishes its turn, see my Bench repo.
  • Edit: I fumble MCP and call it “Model Control Protocol”. It’s the Model Context Protocol, as the slide says.
  • Edit: when you add an MCP server without a scope, the default is local scope, which is private to you and applies only to the current project, not all your projects. Use --scope user for all your projects, and -s project to share it with everyone on the project.
  • Edit: the sharing slide shows git push fork main to publish your build. Your build is on your own branch, so push that branch instead: git push fork week1day3-yourname.

Week 1 Day 4: Open-Source, Local, Token Cost

  • Branches: no product build today, so stay on the branch you’re on.
  • My YouTube videos on parameters and how LLMs work
  • Ollama, LM Studio, vLLM, llmfit and Runpod. The hardware prices on the slides are a snapshot from September 2026, so check them before you buy anything.
  • OpenRouter’s provider routing settings, including order, quantizations and allow_fallbacks. Buying credits by card has a fee of 5.5%, with a minimum of $0.80, as the FAQ explains.
  • The Cerebras part of the lab is optional. If you skip it, take all three Cerebras experiments out of the list at the start of Part 4: qwen_cerebras, qwen_cerebras_low and qwen_cerebras_high. Otherwise you’ll get a NameError.
  • Edit: I say that Amazon Bedrock forwards your call to Anthropic. In fact, AWS runs the models in its own accounts, and the model providers have no access to them. AWS explains it here.
  • Edit: I say OpenRouter gives you its routing for free when you bring your own key (BYOK). It’s free up to a monthly allowance that depends on your plan, and above that OpenRouter charges 5% of what the same usage would normally cost. Here are the current terms.
  • Edit: in my tips for coding agents I say “progressive profiling”. I meant progressive disclosure: giving the agent detail only when it needs it.

Week 1 Day 5: Harness Engineering

Week 2: Become an AI Architect

Week 2 Day 1: Architecture, Evals, Observability

  • Branches: no product build today, so stay on the branch you’re on.
  • Langfuse Cloud. The free Hobby plan needs no credit card, and the current terms are on the pricing page. Langfuse’s guides to tracing LangChain and running experiments.
  • When precision and recall slip your mind again (they always slip mine), there’s a good explainer with the diagram on Wikipedia. And here’s Cohen’s kappa.
  • The optional cleanup cell at the end of the lab deletes every trace in the Langfuse project your keys belong to. Only turn it on in a project you made for this course.
  • Edit: I say an agent that refers everything would score an average penalty of $50. The six claims the handlers referred carry no penalty, so on the 25 harder claims it’s $950 in all, an average of $38.
  • Edit: I say anything over $1,000 is supposed to be referred. The agent can approve a claim over $1,000, but a handler has to sign off before it’s paid. That’s an approval held for sign-off, not a referral.
  • Edit: when I read out the handler’s notes on the burglary in Rome, I say the belongings are unattended and the police will call that night. The notes say the belongings were not unattended, and the police were called that night.
  • Edit: I say the agent never wrongly approved or declined. Neither version wrongly approved, but across my three runs the baseline wrongly declined four times and the payout tool version once.

Week 2 Day 2: Agentic RAG, MCP, Memory

Week 2 Day 3: Durable State & Human in the Loop

  • Branches: git checkout week2day3-start to start the build where I start, or git checkout week2day3-end for my finished build.
  • LangGraph’s docs: the overview, state, nodes, edges, reducers and super-steps, checkpoints and threads, interrupt() and time travel
  • Supabase. The free plan gives you two active projects, and a free project pauses after a week without use. If yours has paused, restore it from the Supabase dashboard. Using a coding agent other than Claude Code? Supabase’s MCP guide has the setup for Codex, OpenCode, GitHub Copilot, Cursor and more.
  • From this product build on, npm run seed resets the queue in Supabase, and uv run -m backend.seed only resets the local SQLite file the tests use.
  • Edit: I say durable execution guarantees that things won’t run twice. After a crash, the step that was running starts again. What stops it doing harm twice is how you design that step, like today’s pay node, which checks whether the claim has already been paid.
  • Clarification: going back to an earlier checkpoint rewinds the graph’s state. It doesn’t undo anything the graph did in the outside world, like a payment. That would take a separate business action, such as a refund.

Week 2 Day 4: Agent Teams, Swarms, Fleet

  • Branches: git checkout week2day4-start to start the build where I start, or git checkout week2day4-end for my finished build. The build is optional, but Day 5’s build starts from it, so if you skip it, check out week2day4-end before Day 5.
  • Claude Code’s agent teams, Kimi’s Agent Swarm and LangSmith Fleet
  • LangGraph’s docs on Send, RetryPolicy and re-execution after a crash, and Langfuse’s guide to adding scores
  • The dashboard starts N at 3, and I run 25 on camera. Start small, especially on free models, which OpenRouter limits to 20 requests a minute.

Week 2 Day 5: Self-Improvement, RSI

  • Branches: git checkout week2day5-start to start the build where I start, or git checkout week2day5-end for my finished build. After switching, run npm run seed as well as npm install.
  • Karpathy’s autoresearch, and my YouTube video on Jev
  • Supabase’s docs on auth and email and password sign-in, LangChain’s HumanInTheLoopMiddleware and Langfuse Sessions
  • The free version of the lab uses one claim from each set to fit in the 50 requests a day that OpenRouter allows on an account without credit. It makes about 40 requests, and if you run short, you can stop after round 1, which makes about 25.
  • Edit: I say autoresearch was maybe the first time people thought about this kind of self-improvement loop. It’s a recent, well-known example, but not the first. The Self-Taught Optimizer paper from October 2023 already had an improver improve its own code.
  • Edit: I say a grade of 1 represents a B. The judge’s scale runs from 0 for F to 3 for A, so 1 is a C and 2 is a B. Higher is better, and the floor of 1.0 in the objectives is a C.
  • Edit: when the first change is rolled back, I say a higher grade number means a worse grade. It’s the other way round. The grade went up a little, which is better, but not by more than the noise threshold, so the change wasn’t kept.
  • The improver never sees the held-out claims, but their average scores decide which versions and recipes we keep. After many rounds, the held-out set has helped choose the configuration too. For a final check, keep a separate test set that the loop never touches. scikit-learn explains validation and test sets.

Week 3: Become an AI FDE

Week 3 Day 1: AI Solutions Architect

  • Branches: no product build today, so stay on the branch you’re on.
  • Two published methodologies for the agent development lifecycle: LangChain’s The Agent Development Lifecycle and Microsoft’s Agent development lifecycle in Microsoft Foundry
  • RICE scoring ranks initiatives by reach, impact, confidence and effort.
  • The European Commission’s overview of the EU AI Act
  • AWS calls it Amazon Bedrock AgentCore. I say AWS Bedrock AgentCore through the course, and it’s the same product. Its documentation starts here.
  • AWS’s guides to MFA for the root user and installing the CLI. On the free route, Render explains its free tier.
  • We use us-east-1 all week, wherever you are. If something you created seems to be missing from the console, check the region selector at the top right first.
  • Edit: I say that with any paid account at OpenAI, Anthropic or Google, your data won’t be used for training. Paying isn’t what decides it. Anthropic’s business and API products don’t train on your inputs by default, but its paid consumer plans, Pro and Max, can use your chats to improve its models if you allow it in your settings. Check the terms and privacy settings for the product you use. Anthropic explains both: commercial products and consumer plans.
  • Edit: I say the Free plan typically comes with $200 of credits. New customers get the same credits on either plan: $100 when they sign up, and up to another $100 for completing activities. You need the Paid plan for this course, because the Free plan can’t use Bedrock AgentCore. AWS compares the two plans.
  • Edit: IAM stands for Identity and Access Management, not Information Access Management. I say it again on Day 4.
  • The Fly.io post I mention is Accident Forgiveness but do note that there are no guarantees; the team at Fly.io puts it nicely in this post. It’s not known whether there are cases that people have been forced to pay for unintended spend.
  • For more on reasoning traces and whether they explain themselves, see Reasoning models don’t always say what they think.

Week 3 Day 2: Security, Guardrails, API Gateways

  • Branches: git checkout week3day2-start to start the build where I start, or git checkout week3day2-end for my finished build.
  • Simon Willison’s post on the lethal trifecta, and two examples: the GitHub MCP exposure written up by Invariant Labs, and Simon’s post on the Supabase MCP
  • AWS’s docs for AgentCore Gateway, AgentCore Policy, AgentCore Identity and Lambda Function URLs
  • The LiteLLM AI Gateway, OpenAPI, and Mangum, which runs the FastAPI app on Lambda
  • If you checked out my branch, add UNDERCOVER_API_KEY to your .env yourself. Letters and numbers are safest, and this prints a random one: uv run python -c "import secrets; print(secrets.token_hex(32))"
  • Edit: at the end of Lab 1, I call the hook we used before_model. The check in the lab uses before_agent, which runs once before the model sees anything. LangChain’s guide to these hooks includes after_model for the assignment.
  • Edit: the architecture slide at the end puts “Wording, manual and notes” in Memory. On Day 3 the policy wording and the claims manual go into the context layer, and Memory holds the agent’s notes on each customer.
  • Cedar is a formal policy language with readable syntax, like the rule in the lab. AgentCore Policy can also turn a rule you write in plain English into Cedar for you.
  • Clarification: I call the three layers bulletproof. The model check looks for instructions hidden in a claim, and it’s the Gateway’s Policy and the app that refuse a payment over $1,000. The lab tests two payments, which shows each control doing its job, but no set of checks makes an agent bulletproof.
  • Note that the Function URL is public, so anyone can call the app. The API key protects the agent’s routes and the handlers sign in for everything else, but the key doesn’t stop the function being called.
  • Running a personal agent on a separate box like a Mac mini keeps it off your main computer, but that doesn’t make it air-gapped. An air gap means no physical or automated connection to other systems at all.

Week 3 Day 3: Enterprise Context Layer & Integrations

  • Branches: git checkout week3day3-start to start the build where I start, or git checkout week3day3-end for my finished build.
  • Philipp Schmid’s post on context engineering, from June 2025
  • Atlan’s article, What an Enterprise Context Layer Actually Is. It’s a vendor’s view.
  • Gartner’s note, How Master Data Management Boosts the Context Layer for AI Agents (June 2026). It’s free, but you need to register.
  • AgentCore Memory’s docs and its built-in strategies: semantic, user preference, summary and episodic
  • The context layer and memory products on the slides are as of October 2026. It’s an early market, so expect new ones. I wondered how to say Mem0: its README says “mem-zero”. And the knowledge graph memory server is one of the MCP project’s reference servers.
  • AWS’s guide to MCP server targets on the Gateway, and the auth types for Function URLs
  • The teardown keeps the app and the context layer on Lambda for Day 4. If you’re stopping here, set DELETE_THE_FUNCTIONS to True to delete them as well.
  • Edit: I say UNDERCOVER_API_KEY is used by the frontend and the backend. It’s the agent’s key. The agent, or the Gateway on its behalf, sends it to the backend, which checks it. The dashboard uses the handler’s sign-in, so never put this key in a frontend setting.

Week 3 Day 4: Production Deployment

  • Branches: git checkout week3day4-start to start the build where I start, or git checkout week3day4-end for my finished build. On week3day4-start, the agentcore and runtime folders are already at the root of the repo, so skip the notebook’s two git mv commands.
  • AgentCore Runtime’s docs, including sessions and long-running work
  • The AgentCore CLI and AWS’s quickstart. Install the CLI at the version in the notebook: I recorded with npm install -g @aws/agentcore@1.0.0-rc.5, and if I test a newer version, I’ll update the notebook.
  • Your first agentcore deploy also sets up the CDK bootstrap in your account. It includes a KMS key that costs $1 a month, and Lab 2 deletes it at the end of the day.
  • agentcore dev uses port 8080, and so does UnderCover’s agent after today’s build. Stop agentcore dev with Ctrl+C before you start UnderCover with npm run dev.
  • Edit: I say 60 seconds is how long the agent is allowed to run, and I say it again in Lab 1. It’s an idle timeout: a session ends after 60 seconds with nothing to do. A session doing work it has registered stays alive for up to 8 hours.
  • Edit: I call npm ci a “clear install”. It stands for clean install: it deletes node_modules and installs exactly what package-lock.json lists.
  • Edit: when the claim resumes in the second session, I read out the start of the reply, which is the agent’s original proposal of $1,180. The reply also has decision, the payout the agent decides with the handler’s note, and paused. Print reply["decision"] to see what it decided.
  • Edit: I say signing off doesn’t go to the agent, and I say the same when I explain the architecture. The app does pay the claim without asking the agent. It then starts a short session so the agent can finish the claim’s graph and save the claim to Memory.

Week 3 Day 5: Capstone

  • Branches: git checkout week3day5-start to start the build where I start, or git checkout week3day5-end for my finished build.
  • The interactive diagram of the Copilot’s LangGraph graph that Claude made for me. The graph itself is in agent/copilot/graph.py on the week3day5-end branch.
  • My AI Coder course shows how to set up a skill so that Claude Code hands work like the plan review to Codex.
  • In Part 2 of Lab 2, run its three commands in your terminal (agentcore remove all --yes, agentcore deploy --yes and git restore agentcore/agentcore.json) before the cell that takes the settings out of .env.local. I don’t mention them in the video. If Part 5 says it’s keeping the CDK bootstrap, the runtimes’ stack is still there: run those commands, then run the cell again.
  • A new AWS account already has some resources of its own, such as the default network in each Region, so the list of everything on your account won’t be empty. The notes in Lab 2 explain what should stay. Resource Explorer searches us-east-1 unless you turn on cross-Region search.
  • AWS updates the budget figures up to three times a day, so check your spend again over the next day or two. If you’ve finished with AWS for now, deactivate your IAM user’s access key, as the end of Lab 2 explains.
  • Edit: when I compare the Copilot’s memory with the claim agent’s, I say the claim agent’s memory is focused on one particular claim. It’s organized by customer: while working a claim, the claim agent can find facts and summaries from that customer’s earlier claims. The Copilot’s memory is organized by handler.
  • Edit: when I say I’m asking Copilot for a second opinion on the plan, I mean Codex.
  • Clarification: straight through in the success criteria counts every claim the agent didn’t refer, including approvals over $1,000 that wait for a handler to sign off the payment.

Thank you for making it to the end of the resources! Since you’ve made it this far, you should definitely consider connecting or following me on LinkedIn and subscribing on YouTube. And say hi in Udemy! And if you’ve made it to the end of the course, then congratulations – please consider sharing your certificate to celebrate your success.

One response to “AI FDE: The Forward Deployed Engineer & Agentic AI Architect”

  1. Faisal Alkheraiji Avatar
    Faisal Alkheraiji

    I’m excited to start this journey.

    Love your courses Ed ! Thank you for making these ❤️

    Reply

Leave a Reply

Discover more from Edward Donner

Subscribe now to keep reading and get access to the full archive.

Continue reading