20-hour starter plus 12-week track

Become useful as an FDE faster

A Claude-assisted plan for getting to first FDE competence in 20 focused hours, then continuing into the original 12-week interview-backward curriculum.

Start 20 Hours Open Source Resource Project
01 / How To Use This

Two projects, one learning loop

This version keeps the original 12-week plan and adds a faster Claude-assisted path: first turn the best FDE materials into an open resource project, then use a curated subset to run a personal 20-hour starter sprint.

2

Subprojects

An open GitHub resource library and a private 20-hour learning sprint that uses it.

20h

Starter Sprint

Enough time to learn the FDE map, build a thin slice, explain tradeoffs, and run a mock loop.

1

Resource Repo

A public, curated answer to: “If I want to become an FDE, what matters most?”

12

Weeks Preserved

The original long-form curriculum remains available as the next layer after the sprint.

Claude learning rhythm

  1. Define the target performance: what an entry FDE must be able to do.
  2. Ask Claude to filter resources by task relevance, not popularity.
  3. Learn by producing artifacts: scope, architecture, prototype, eval, demo.
  4. Use Claude as examiner: force recall, critique gaps, and rewrite weaker answers.

Starter capstone theme

Build an “AI Deployment Assistant” for a realistic business workflow. In the 20-hour version, the goal is not production depth; it is a defensible thin slice that proves you understand discovery, architecture, evals, and rollout.

FastAPI Postgres RAG Evals AI architecture
02 / Claude Methodology

Use Claude as teacher, curator, examiner, and reviewer

This section adapts Rahul's X article, “How To Learn Anything 10x Faster Using Claude,” into an FDE plan. The full method is six prompts: learning ladder, 20-hour plan, quiz until failure, one-page cheat sheet, signal-in-noise resource curation, and the Feynman loop.

source: Rahul on X
1

Build a Learning Ladder

Break FDE into five levels, from beginner to confident practitioner. Each level needs a milestone, a hands-on exercise, common mistakes, and a self-check before moving forward.

2

Learn in 20 Hours

Extract the 20% of FDE concepts that create 80% of real-world progress, then structure them into ten 2-hour sessions with one resource, one exercise, and five review questions each.

3

Quiz Until I Break

After each session, use active recall: ten progressively harder questions, one at a time, with grading, gap detection, and re-teaching only what was missed.

4

Create a One-Page Cheat Sheet

Compress each FDE topic into a scannable page: definition, key concepts, mental model, examples, common mistakes, checklist, and rapid-fire memory questions.

5

Find the Signal in the Noise

Limit the resource set to the five highest-leverage materials. For each one, capture why it matters, what it teaches, who it fits, how to use it, and what not to waste time on.

6

Use the Feynman Loop

Explain the concept in simple language, then explain it back. Claude identifies gaps, re-teaches only the weak parts, and repeats until the explanation is simple and complete.

03 / Subproject 1

Open-source the FDE resource library

Turn the resource collection into a public GitHub project with a clear editorial stance: not “everything about AI,” but the most important resources for becoming useful as a Forward Deployed Engineer.

repo name: awesome-fde-resources

Public title

Use the public title “Awesome FDE Resources,” with a clear subtitle for discoverability: “A curated resource map for learning Forward Deployed Engineering.”

Repository structure

  • README.md: opinionated learning map and quick start.
  • resources/: links grouped by FDE task.
  • CONTRIBUTING.md: resource acceptance criteria.
  • LICENSE: license for original writing and notes.

Editorial rule

A resource earns a place only if it helps someone ship or explain an FDE artifact: customer discovery, AI architecture, LLM app engineering, RAG, evals, security, deployment, or executive communication.

GitHub launch checklist

  1. Create the repo with MIT or CC BY 4.0 license. Use CC BY 4.0 if most value is curated writing and resource notes.
  2. Import current resources from this site and tag each item by skill, artifact, difficulty, and time cost.
  3. Keep the repo focused on resource sharing first; leave learning paths, playbooks, and templates as TODOs until they are mature.
  4. Add contribution rules: no link dumps, no paywalled-only resources, explain why each resource matters.
  5. Publish a first issue list: missing examples, better FDE job descriptions, stronger eval resources, case studies.

README promise

This repo should answer four questions fast: What does an FDE actually do? What should I learn first? Which resources are worth my limited time? What artifacts prove I am improving?

04 / Subproject 2

Your personal 20-hour FDE starter plan

This is an execution plan, not a reading list. Each 2-hour session has resources, timed work, a Claude prompt, a required output, and a pass/fail check. The goal is to finish with a defensible FDE thin-slice project and interview narrative.

Build your FDE learning ladder

Resources: Anthropic FDE posting, OpenAI FDE posting, Awesome FDE Resources section 1.

  1. 0:00-0:25 - Read both job postings. Write down repeated expectations, not buzzwords.
  2. 0:25-0:55 - Run the learning-ladder prompt below with your current background.
  3. 0:55-1:30 - Create five FDE levels: observer, analyst, builder, deployer, trusted advisor.
  4. 1:30-2:00 - Write your baseline: strongest 3 skills, weakest 3 skills, and one 20-hour outcome.

Claude prompt: “Break FDE into 5 levels for me personally. For each level, define mastery, key concepts, one milestone, one hands-on exercise, common mistakes, and a self-check question. Assume my goal is to become credible enough to discuss and prototype enterprise AI deployments.”

Output: one-page FDE learning ladder and personal gap list. Pass: you can explain what an FDE does in 90 seconds without saying only “build AI apps.”

Choose the right workflow, not the flashiest AI idea

Resources: Stanford Enterprise AI Playbook, Google use-case guide, RAND AI failure report.

  1. 0:00-0:30 - Scan the resources for selection criteria: value, feasibility, data, adoption, risk.
  2. 0:30-1:10 - Score four candidate workflows: support triage, sales account research, document intake, operations knowledge assistant.
  3. 1:10-1:35 - Pick one workflow and reject two alternatives.
  4. 1:35-2:00 - Write the first version of your use-case memo.

Claude prompt: “Act as an enterprise AI deployment advisor. Given these candidate workflows, help me score value, feasibility, data readiness, risk, adoption path, and AI fit. Push back on weak assumptions. Recommend one workflow for a 20-hour FDE prototype and explain which two I should reject.”

Output: use-case memo with selected workflow, rejected alternatives, target user, metric, non-goals, and adoption risk. Pass: you can defend why this workflow deserves a pilot.

Turn vague pain into customer discovery

Resources: YC How to Talk to Users, Google People + AI Guidebook, Atlassian project poster.

  1. 0:00-0:25 - Draft the current workflow in 6 steps.
  2. 0:25-0:55 - Write 10 discovery questions: 5 for an executive, 5 for a frontline user.
  3. 0:55-1:25 - Identify data sources, decision owners, failure consequences, and adoption blockers.
  4. 1:25-2:00 - Write a one-page scope poster: goal, non-goals, users, risks, pilot boundary.

Claude prompt: “Act as a skeptical customer discovery coach. Review my workflow and questions. Find vague assumptions, missing stakeholders, adoption risks, and questions that would produce shallow answers. Rewrite my discovery plan so it can uncover whether this AI deployment is worth building.”

Output: discovery script and scope poster. Pass: your questions would reveal data readiness, workflow ownership, and adoption risk.

Design the solution architecture

Resources: Anthropic Building Effective Agents, OpenAI agent guide, AWS enterprise agentic AI architecture, System Design Primer.

  1. 0:00-0:30 - Decide if this should be deterministic workflow, structured output, RAG, tool use, or agent loop.
  2. 0:30-1:00 - Draw the text architecture: UI, API, data, model, tools/RAG, evals, logs, human review.
  3. 1:00-1:30 - Write tradeoffs: latency, cost, reliability, permissions, auditability, fallback.
  4. 1:30-2:00 - Run the Feynman loop until you can explain the architecture simply.

Claude prompt: “Review this AI architecture like a senior FDE. Tell me where I am overusing agents, where deterministic workflow is better, what data and permission boundaries are missing, what can fail, and what I must log/evaluate before pilot.”

Output: architecture memo. Pass: every component has a purpose and every major risk has a mitigation.

Build the backend skeleton

Resources: FastAPI tutorial, FastAPI testing guide, Microsoft REST API guidelines.

  1. 0:00-0:20 - Define the API contract: ingest record, list records, analyze record, return recommendation.
  2. 0:20-1:20 - Build or pseudo-code the endpoints with request/response schemas.
  3. 1:20-1:45 - Add 3 tests: happy path, missing data, invalid status or type.
  4. 1:45-2:00 - Write implementation notes if the app is not fully running.

Claude prompt: “Act as my backend reviewer. Given this API contract for my FDE prototype, critique the data model, validation, error handling, integration boundaries, and tests. Keep it minimal enough for a 20-hour prototype.”

Output: backend skeleton or precise implementation spec. Pass: another engineer could implement the API without guessing the workflow.

Add the AI behavior

Resources: OpenAI structured outputs, Claude tool use docs, Anthropic writing tools for agents.

  1. 0:00-0:25 - Define the model output schema: recommendation, confidence, rationale, missing info, escalation flag.
  2. 0:25-1:10 - Implement or pseudo-code the model/tool call with validation and fallback.
  3. 1:10-1:35 - Run 3 sample records through the flow.
  4. 1:35-2:00 - Log prompt version, model choice, validation result, latency estimate, and failure path.

Claude prompt: “Design a structured output schema and tool-call flow for this workflow. Include validation rules, fallback behavior, when to escalate to a human, and what logs I need for debugging and evals.”

Output: one end-to-end AI thin slice. Pass: the output is typed, reviewable, and has a defined failure path.

Add knowledge and retrieval judgment

Resources: Claude RAG guide, Azure AI Search RAG overview, Microsoft GraphRAG docs.

  1. 0:00-0:25 - Decide if your workflow needs RAG now, later, or not at all.
  2. 0:25-1:00 - Define 10 source records or documents and the metadata needed for filtering.
  3. 1:00-1:30 - Write 8 retrieval test questions with expected source documents.
  4. 1:30-2:00 - Identify retrieval failure modes: missing source, stale source, wrong permission, noisy chunk.

Claude prompt: “Evaluate whether this FDE prototype needs RAG. If yes, design chunking, metadata, permissions, retrieval tests, citations, and failure debugging. If no, explain what simpler data access pattern is enough for the first pilot.”

Output: knowledge architecture note and retrieval test set. Pass: you can explain whether RAG is necessary and how you would debug wrong answers.

Evaluate reliability, safety, and risk

Resources: OpenAI Evals guide, Hamel/Shankar Evals FAQ, OWASP LLM Top 10, NIST AI RMF.

  1. 0:00-0:35 - Create 10 eval cases: normal, ambiguous, missing data, unsafe, adversarial, edge cases.
  2. 0:35-1:05 - Define metrics: task success, groundedness, schema validity, refusal, latency, cost.
  3. 1:05-1:35 - Write a lightweight threat model: prompt injection, data leakage, wrong action, over-autonomy.
  4. 1:35-2:00 - Produce a short eval report with 3 fixes before pilot.

Claude prompt: “Act as a strict AI eval and security reviewer. Given my workflow and architecture, create an eval set, scoring rubric, failure taxonomy, and threat model. Identify what must be fixed before pilot users touch it.”

Output: eval report and risk register. Pass: you have concrete examples of failure, not generic warnings.

Plan adoption and learn from real deployments

Resources: Stanford Enterprise AI Playbook, Klarna case, Morgan Stanley case, Air Canada case, McDonald's drive-thru AI case, RAND failure report.

  1. 0:00-0:30 - Extract 5 adoption lessons from the success and failure cases.
  2. 0:30-1:05 - Write your pilot rollout plan: users, owner, training, support, feedback, rollback.
  3. 1:05-1:35 - Define business success: baseline, target metric, measurement window, decision gate.
  4. 1:35-2:00 - Write the customer-facing deployment narrative.

Claude prompt: “Use these enterprise AI success and failure cases to critique my rollout plan. Find adoption risks, accountability gaps, measurement gaps, and places where the customer may lose trust. Rewrite the plan so it is credible for a controlled pilot.”

Output: rollout memo and deployment narrative. Pass: the plan names an owner, metric, rollback path, and trust boundary.

Run the mock FDE loop and compress the learning

Resources: all artifacts from S1-S9.

  1. 0:00-0:25 - Create a one-page cheat sheet from your artifacts.
  2. 0:25-1:05 - Run “quiz until I break”: 10 questions, one at a time.
  3. 1:05-1:35 - Run a 30-minute mock FDE interview: use case, architecture, build, evals, risk, rollout.
  4. 1:35-2:00 - Write your answer bank and top 5 gaps for the 12-week plan.

Claude prompt: “Act as a strict FDE interviewer. Ask one question at a time across use-case selection, customer discovery, architecture, implementation, RAG/tools, evals, security, adoption, and communication. Grade each answer, push on vague claims, and end with my top 5 gaps.”

Output: cheat sheet, answer bank, and 12-week follow-up backlog. Pass: you can give a 5-minute coherent story of the deployment and survive follow-up questions.

Prompt: learning ladder

“I want to learn Forward Deployed Engineering step by step. Break FDE into 5 levels from complete beginner to confident practitioner. For each level, define mastery, key concepts, one milestone, one hands-on exercise, common mistakes, and one self-check question.”

Prompt: 20-hour plan

“I want to learn FDE in 20 focused hours. Identify the 20% of concepts and skills that create 80% of practical FDE competence. Build a 10-session plan, 2 hours each, with a goal, concepts, exercise, one resource, expected outcome, and 5 review questions.”

Prompt: quiz until I break

“I just studied this FDE topic. Ask me 10 progressively harder questions, one at a time. After each answer, grade me out of 10, tell me what I got right, identify the exact gap, and re-explain only what I missed.”

Prompt: cheat sheet

“Create a one-page cheat sheet for this FDE topic. Include a simple definition, key concepts, a mental model or flow, concrete examples, common mistakes, a before-you-use-this checklist, and 5 rapid-fire questions.”

Prompt: signal finder

“Act as my FDE learning curator. Select the 5 highest-leverage resources for this FDE skill. For each, explain why it matters, what it teaches, learner fit, difficulty, how to use it, and what not to waste time on. Rank them in order.”

Prompt: Feynman loop

“Teach this FDE concept in simple language. Then ask me to explain it back. Review my explanation, identify gaps or mistakes, re-teach only the weak parts, and repeat until my explanation is simple, accurate, and complete.”

05 / Original Weekly Plan

12-week FDE Coach curriculum

Use the filters to focus your study. Check off each week when your deliverable and test are done; progress is saved locally in this browser.

See Questions
0 of 12 weeks complete
06 / Interview Backward Design

Train against the questions first

The weekly tests are built from common FDE interview loops: AI architecture, AI use-case selection, production LLM engineering, customer discovery, security, execution under ambiguity, and communication. Each week gives you questions to answer out loud and artifacts to prove the answer is real.

AI architecture

  • Design an AI assistant for a regulated enterprise workflow. What components do you need?
  • When would you choose RAG, fine-tuning, tools, agents, or a deterministic workflow?
  • How do you handle latency, cost, reliability, permissions, and observability?

AI use cases

  • How do you identify where AI creates measurable business value?
  • Which use cases should be rejected because data, risk, or adoption is not ready?
  • How would you prioritize support, sales, operations, finance, legal, and engineering workflows?

Customer deployment

  • A customer says the prototype is impressive but unsafe. What do you do next?
  • How do you get from demo to adoption across real users?
  • How do you translate product feedback into reusable platform improvements?

Production LLM engineering

  • How do you evaluate answer quality beyond “looks good”?
  • How do you debug hallucination, retrieval failure, tool failure, and prompt injection?
  • What should be logged, monitored, and alerted in production?

Execution and ambiguity

  • You have two weeks to deliver a prototype. What do you cut and what do you keep?
  • How do you make decisions when requirements conflict across business, security, and engineering teams?
  • Tell me about a time you took ownership without a clean spec.

Code and system fundamentals

  • Build an API endpoint and explain its data model, failure modes, and tests.
  • Design the ingestion pipeline for customer documents, events, and permissions.
  • How would you make the system maintainable for the customer after you leave?

Agentic AI architecture

  • What is the agent loop: goal, context, plan, tool call, observation, reflection, and stop condition?
  • Where do you put orchestration, memory, tool registry, permissions, evals, and human approval?
  • When is an agent the wrong architecture compared with RAG, workflow automation, or plain software?

Enterprise CEO lens

  • What business KPI changes, and who owns the result after the FDE leaves?
  • What can the agent do autonomously, what needs approval, and what must never be delegated?
  • How do we prevent agent sprawl, hidden cost, vendor lock-in, compliance risk, and brand damage?

AgentOps

  • How do you monitor tool success, task completion, reasoning traces, cost, latency, and escalation rate?
  • How do you test agents before production when behavior is multi-step and nondeterministic?
  • What is the rollback path if the agent starts taking the wrong actions?

Domain knowledge architecture

  • When is simple vector RAG enough, and when do you need hybrid search, metadata, or GraphRAG?
  • How do you model domain concepts, permissions, freshness, source quality, and contradictions?
  • How do you prove the knowledge base is trustworthy enough for enterprise users?

Data readiness

  • Which documents, systems, and operational records are authoritative?
  • What is stale, duplicated, inaccessible, poorly structured, or legally sensitive?
  • How do you build ingestion, refresh, access control, and source citation into the architecture?

Decision boundary

  • Should this be RAG, GraphRAG, fine-tuning, an agent workflow, or classic search?
  • What accuracy, explainability, latency, and cost tradeoffs come with each choice?
  • How would you explain that choice to a CEO, security lead, and engineering lead?
07 / Prototype Test Lab

Submit one answer and get evaluator feedback

This is a lightweight prototype for the weekly tests. It is not a true LLM grader yet; it acts like a rubric agent in the browser, checking whether your answer covers the interview prompt, architecture/use-case reasoning, evidence, risks, and next actions. If this proves useful, the next version can connect to a real evaluator backend.

Submission

Pick a week, paste your answer, then run the evaluator. Good answers usually include a clear recommendation, tradeoffs, measurable success criteria, risks, and implementation details.

Evaluator feedback

Feedback will appear here after you submit. The evaluator is intentionally strict: vague answers score low even if they sound polished.

08 / Enterprise Readiness

Questions a CEO or enterprise sponsor will ask

An FDE profile is strongest when it can move beyond model demos and answer deployment-risk questions in business language. These are the questions the curriculum now trains toward.

Value and ownership

  • Which workflow KPI changes, and how quickly?
  • Who owns adoption, support, and business outcome after launch?
  • What budget, staffing, and change-management effort is required?

Control and risk

  • What can the agent do without approval, and where must humans stay in control?
  • How are identity, permissions, audit logs, data retention, and rollback handled?
  • What failure would damage trust, compliance, or brand reputation?

Scale and architecture

  • Will this become one agent, a workflow, a platform capability, or an agent mesh?
  • How do agents connect to APIs, data, tools, and existing systems without creating brittle debt?
  • How do we monitor, evaluate, govern, and retire agents over time?
09 / Portfolio

What you should have by the end

This is the interview package. It should feel like a real deployment story, not a toy notebook.

Working app

Deployed capstone with auth-like access assumptions, realistic data ingestion, RAG or tools, and an observable backend.

Architecture memo

Problem, users, system design, model choices, data flow, security posture, failure modes, and rollout plan.

Evaluation report

Golden dataset, metrics, examples of pass/fail behavior, manual review rubric, and cost/latency notes.

Demo narrative

Five-minute customer-style demo showing before/after workflow value, not just a tour of features.

10 / Public Materials

Resource library used in the weekly plan

This section mirrors the weekly curriculum. Strong supplemental knowledge bases are kept when they support a specific week, and each resource appears once.

Role, use case, and customer discovery