ALL ROADMAPS/
AI FORWARD DEPLOYED ENGINEER (FDE) // 6-MONTH CURRICULUM
6 STAGES24 WEEKS176 LESSONS6 PORTFOLIO BUILDS
HALF ENGINEER, HALF CONSULTANT

Own the Last Mile Between a Model and a Business Result

A Forward Deployed Engineer sits with a client, finds the real problem worth solving, and builds and ships the AI system that solves it inside the client's own systems, data, and compliance rules. The job is measured on business KPIs, not model scores.

YOUR FDE RANKRecruit
0 / 8,620 XP0%
Next: Backend Ready (1,200 XP left)
6-MONTH TIMELINE REGISTER // 3 MONTHS SKILLS + 3 MONTHS DEPLOYABILITY6 STAGES · 6 MAJOR CAPSTONES
FILTERING 6 STAGES & 24 WEEKS
TENET 01Measured on Business KPIs

A model score (like 89% MMLU) means nothing to a client. You are measured on claims processed per hour, dispute resolution speed, and dollar savings.

TENET 02Works in Legacy Reality

Clients run SharePoint, Salesforce, SAP, and private on-prem VPCs. You must make AI work with existing security, OAuth, and compliance boundaries.

TENET 03Build & Hand Over

Each month culminates in a complete production capstone with a tested repository, SOW, architecture diagrams, and client handover runbooks.

STAGE 1 // MONTH 1+1400 XPUnlocks: Backend Ready

Foundations: Production Backend & LLM Mechanics

Be a competent backend engineer who understands what actually happens when an LLM is called.

A forward deployed engineer cannot hide behind notebook scripts. You must write production-grade Python that an enterprise team can run inside their VPC. Week 1 makes your Python bulletproof, week 2 covers structured data & APIs, week 3 terminal fluency & Docker, and week 4 LLM tokens and sampling. The month ends with a Dockerised Document Q&A API.

CLIENT IMPACT WEIGHT8 / 10

Enterprise clients won't let you touch their data unless your code meets their standard backend security, testing, and containerization standards.

TECHNICAL RIGOR WEIGHT9 / 10

Async event loops, strict Pydantic schemas, and Docker Compose reproducibility prevent 90% of on-site deployment failures.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 113 lessons

Python for Production & Project Packaging

Classes, dataclasses, type hints, Pydantic v2, async/await, pyproject.toml, and logging instead of print.

Core Takeaways:
  • •Dataclasses and Pydantic v2 validation models
  • •Asyncio event loops, coroutines, and task groups
  • •Retries with exponential backoff and jitter (tenacity)
ROI: Code that can be audited by client security architects and maintained by their engineering staff.
WEEK 212 lessons

Files, SQL & REST APIs with FastAPI

Moving data in and out of JSON, SQL joins/indexes on real DBs, and typed FastAPI endpoints.

Core Takeaways:
  • •Streaming file uploads & chunked buffer processing
  • •PostgreSQL indexing, joins, and ACID transactions
  • •FastAPI dependency injection and middleware
ROI: Clean API contract and database schemas that plug into client data pipelines.
WEEK 310 lessons

Developer Tooling & Claude Code in Repos

Using Claude Code as an in-repo coding agent, Git branching hygiene, Linux shell fluency, and Docker.

Core Takeaways:
  • •Claude Code CLI: codebase search, planning before writing, rewinding mistakes
  • •Git worktrees, semantic commits, and PR code reviews
  • •Linux system diagnostics (htop, curl, grep, systemd)
ROI: 10x engineering velocity when modifying foreign legacy codebases on client engagements.
WEEK 412 lessons

How LLMs Actually Work

Transformers in one picture, tokens, next-token prediction, sampling controls, context limits, and model APIs.

Core Takeaways:
  • •Autoregressive generation & next-token probability distribution
  • •Tokenization boundaries, BPE algorithms, and token-cost math
  • •Temperature, top-p, frequency penalty, and presence penalty
ROI: Educating client VPs and technical leads on what models can and cannot do reliably.
MONTH 1 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

Document Q&A Microservice API

A FastAPI microservice that accepts PDFs, parses structured text, and answers grounded questions via LLM with strict JSON schemas, tested with Pytest and containerized with Docker Compose.

Client Engagement Scenario:

Internal legal department needs an API to query compliance handbooks without data leaking to public endpoints.

Target Business KPI:

P95 latency under 1.8s; 100% test pass rate in CI; zero unhandled 500 errors on corrupt PDFs.

Stack:Python 3.12FastAPIPydanticDockerPytesthttpx
Stage Frameworks:Python 3.12FastAPIPydanticDockerClaude CodePytest
STAGE 2 // MONTH 2+1500 XPUnlocks: LLM Engineer

LLM Engineering: Grounding, RAG & Evals

Build LLM features that are reliable in business reality, not just demos, and prove it with evals.

Enterprise clients don't want chatbots that hallucinate policy clauses. Learn to steer models with structured schemas, ingest large document corpora, ground answers strictly in citations with explicit refusal triggers, and measure accuracy before and after tuning using golden datasets and RAGAS.

CLIENT IMPACT WEIGHT10 / 10

A client will cancel a contract if the AI hallucinates a non-existent policy benefit or leaks competitor data. Grounding and citations are mandatory.

TECHNICAL RIGOR WEIGHT10 / 10

Hybrid search (dense vector + BM25 keyword) with cross-encoder re-ranking and RAGAS eval metrics turns guesswork into scientific engineering.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 59 lessons

Steering Models & Tool Calling

System prompts, few-shot demonstration calibration, structured outputs, and LangChain tool binding.

Core Takeaways:
  • •System instructions, XML delimiters, and negative constraints
  • •Few-shot calibration for edge-case reasoning
  • •LangChain tool calling: bind_tools, streaming steps, typed outputs
ROI: Enforcing deterministic JSON payloads that feed downstream enterprise databases.
WEEK 615 lessons

Ingestion, Vector Stores & Hybrid Search

Splitting docs, dense embeddings, vector stores (pgvector/Qdrant), BM25 keyword matching, and reranking.

Core Takeaways:
  • •Document ingestion, hierarchy preservation, and metadata tagging
  • •Vector databases: pgvector, Qdrant, Pinecone trade-offs
  • •BM25 keyword search combined with vector search (Reciprocal Rank Fusion)
ROI: High-precision retrieval across complex internal enterprise PDF archives and wiki hubs.
WEEK 711 lessons

Grounded RAG, Citations & Advanced Strategies

Verifiable citations, safe refusals, HyDE (Hypothetical Document Embeddings), and parent-child retrieval.

Core Takeaways:
  • •Citations extraction: linking answers to exact character spans
  • •Refusal conditioning: answering ONLY from retrieved context
  • •Parent-child chunking: searching small chunks, feeding full parent section
ROI: Eliminating hallucination risk so legal and compliance teams approve production rollout.
WEEK 814 lessons

Golden Datasets & LLM-as-a-Judge Evals

Curating real test cases, RAGAS metrics (Faithfulness, Relevancy, Precision), and regression testing.

Core Takeaways:
  • •Curating golden evaluation datasets with business stakeholders
  • •RAGAS triad: Faithfulness, Answer Relevancy, Context Precision/Recall
  • •Promptfoo regression test suites running on every prompt change
ROI: Executive reports with hard metrics proving the AI system is ready for customer-facing deployment.
MONTH 2 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

Enterprise Policy RAG Assistant with Eval Dashboard

Build a citation-grounded RAG engine over complex insurance policies or enterprise contracts. Returns verifiable source quotes, explicitly refuses when ungrounded, and features an evaluation dashboard proving accuracy gains on a 50-question golden dataset.

Client Engagement Scenario:

Insurance carrier needs claims processors to query 200-page policy binders with zero hallucinated coverage clauses.

Target Business KPI:

Faithfulness score > 0.92; Citation accuracy 100%; Zero false coverage affirmations.

Stack:PythonLlamaIndexQdrantCohereRAGASFastAPI
Stage Frameworks:LlamaIndexLangChainRAGASpgvector / QdrantCohere RerankPromptfoo
STAGE 3 // MONTH 3+1600 XPUnlocks: Agent Engineer

Agentic AI: Workflows, Tools, Memory & Guardrails

Design agents that take safe, audited actions inside enterprise operational workflows.

Single-turn Q&A isn't enough; FDEs automate complex business processes. Week 1 teaches agent loops & memory; week 2 state machines with LangGraph, Deep Agents, and OpenAI Agents SDK; week 3 Anthropic's Model Context Protocol (MCP) and human-in-the-loop approvals; week 4 enterprise guardrails with NeMo. The project is an operational ticket agent.

CLIENT IMPACT WEIGHT10 / 10

Enterprise workflows have high consequences: issuing refunds, updating records, creating Jira tickets. Human approval gates and permission scoping are non-negotiable.

TECHNICAL RIGOR WEIGHT10 / 10

Replacing unpredictable while-loops with deterministic LangGraph state machines and sandboxed tools.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 915 lessons

The Agent Loop, Tool Design & Memory

ReAct loops, parallel tool execution, error recovery, and long-term episodic memory with LangMem/Mem0.

Core Takeaways:
  • •create_agent and the ReAct (Reason + Act) loop
  • •Tool execution error handling and observation feedback to model
  • •Parallel tool calling and state reconciliation
ROI: Systems that remember previous client interactions and recover gracefully from API glitches.
WEEK 1018 lessons

Agent Frameworks: LangGraph, Deep Agents & OpenAI SDK

State graphs, nodes, edges, subagents, and standard harnesses.

Core Takeaways:
  • •LangGraph: Typed state, conditional edges, cycles, and checkpoints
  • •Deep Agents: Planning with write_todos, virtual filesystem, and context offloading
  • •OpenAI Agents SDK: Handoffs, agents-as-tools, and runner loops
ROI: Choosing the exact right agent framework for the client's existing stack and team capability.
WEEK 1116 lessons

Model Context Protocol (MCP) & Human-in-the-Loop

Anthropic's open MCP standard for tools, context engineering, and human approval interrupts.

Core Takeaways:
  • •Building custom MCP servers with typed tools and resource schemas
  • •MCP client integration over stdio and remote HTTP SSE transports
  • •Context engineering: token budgeting, trimming, and thread summarization
ROI: Zero vendor lock-in with industry-standard MCP tool integrations; legal peace-of-mind with human gates.
WEEK 1212 lessons

Guardrails, Permissions & Code Sandboxing

NeMo Guardrails, Colang flows, PII masking, call limits, and sandboxed code execution with E2B.

Core Takeaways:
  • •NeMo Guardrails: Colang intents, input rails before LLM, output rails after
  • •Defending against jailbreaks and prompt injection attempts
  • •Tool permission scoping: read-only vs destructive operations
ROI: Guaranteed enterprise security compliance and protection against accidental database wipes.
MONTH 3 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

Ops Workflow Automation Agent with Human Gate

An autonomous multi-step agent that monitors incoming support/ops tickets, queries internal databases via MCP tools, drafts corrective actions, pauses for human manager review on high-risk operations, and emits full OpenTelemetry traces.

Client Engagement Scenario:

Fintech customer support desk needs to automate account dispute workflows while keeping human sign-off on transactions over $500.

Target Business KPI:

70% reduction in ticket resolution time; 100% adherence to human approval threshold.

Stack:PythonLangGraphMCP SDKNeMo GuardrailsFastAPI
Stage Frameworks:LangGraphModel Context Protocol (MCP)Deep AgentsOpenAI Agents SDKNeMo GuardrailsMem0
STAGE 4 // MONTH 4+1500 XPUnlocks: Production Shipper

Production & Deployment: Reliability, Tracing & Scale

Ship an AI system that stays up 24/7, stays cheap, and stays fully observable.

Demos belong in Jupyter; FDEs ship to production clouds. Week 1 is high-throughput serving & Kubernetes/Helm; week 2 CI/CD with automated evals in GitHub Actions; week 3 distributed tracing with LangSmith/Langfuse; week 4 model gateways with LiteLLM and latency budgets. The project deploys your agent to cloud with CI/CD and fallback models.

CLIENT IMPACT WEIGHT9 / 10

Enterprise clients care about SLAs, 99.9% uptime, zero data leaks, and predictable cloud bills. Without LLMOps, pilots die in staging.

TECHNICAL RIGOR WEIGHT10 / 10

LiteLLM gateways, OpenTelemetry spans, automated PR eval gates, and multi-cloud container orchestration.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 1314 lessons

Production Serving & Cloud Infrastructure

Serving graphs, FastAPI behind Uvicorn/Gunicorn, Kubernetes pods & Helm charts, and AWS/GCP cloud basics.

Core Takeaways:
  • •Streaming progress and tokens with SSE in production FastAPI
  • •Kubernetes architecture: Deployments, Services, Ingress, and Helm charts
  • •Cloud provider fundamentals: VPCs, IAM roles, and managed compute
ROI: Deploying directly into the client's own cloud infrastructure without friction.
WEEK 1412 lessons

Automated CI/CD & Headless Evals

Running Claude Code in GitHub Actions, PR review bots, and automated golden dataset eval gates.

Core Takeaways:
  • •Headless Claude Code in CI: reviewing PRs, checking schema regressions
  • •Running RAGAS golden evaluations on every commit and failing on score drop
  • •Multi-environment deployment pipelines (dev -> staging -> prod)
ROI: Catching model regressions before code touches production customers.
WEEK 1513 lessons

Distributed Observability & Telemetry

Tracing with LangSmith and Langfuse, OpenTelemetry, token and cost dashboards, and user feedback.

Core Takeaways:
  • •Instrumenting end-to-end spans across API, tools, retrieval, and LLM
  • •Langfuse open-source self-hosting and session tracking
  • •Cost and token consumption attribution by department/feature
ROI: Full visibility for client leadership on usage, ROI, and real-time system performance.
WEEK 1611 lessons

Model Gateways, Fallbacks & Latency Budgets

LiteLLM gateway, unified endpoints, circuit breakers, semantic caching, and load testing.

Core Takeaways:
  • •LiteLLM: one endpoint for OpenAI, Anthropic, Gemini, and open weights
  • •Configuring model fallback waterfalls (e.g., Anthropic -> Gemini -> Groq)
  • •Redis semantic caching to eliminate redundant LLM invocations
ROI: Immunity to upstream AI vendor outages and predictable infrastructure bills.
MONTH 4 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

Cloud-Deployed Agent Platform with LiteLLM Gateway

Deploy the Month 3 agent to cloud infrastructure with automated GitHub Actions CI/CD, Langfuse distributed tracing, a LiteLLM gateway with fallback routing to Claude/Gemini, and a live cost & latency telemetry dashboard.

Client Engagement Scenario:

E-commerce client needs an agent to handle 50,000 monthly product inquiries with a strict 3-second latency SLA and automatic fallback during OpenAI outages.

Target Business KPI:

99.95% availability through simulated provider outages; 40% cost reduction via caching.

Stack:DockerKubernetes / ECSLiteLLMLangfuseFastAPI
Stage Frameworks:FastAPIDockerKubernetesLangfuseLiteLLMGitHub ActionsTerraform
STAGE 5 // MONTH 5+1500 XPUnlocks: Enterprise Integrator

Enterprise Integration: Data, Security, SSO & Compliance

Make AI work with the legacy systems, sensitive data, and compliance rules a real company already has.

FDEs don't build greenfield apps; they integrate AI into messy existing systems. Week 1 is SSO, OAuth2 & RBAC; week 2 connecting to SharePoint, Salesforce, SAP, Jira, and S3 with incremental sync; week 3 SOC2, GDPR, DPDP Act & HIPAA compliance; week 4 private VPC and self-hosted open-weight models with vLLM. The project is a secure enterprise copilot.

CLIENT IMPACT WEIGHT10 / 10

Enterprise deals stall in security review unless you can prove per-user document permissions and HIPAA/SOC2 data boundaries.

TECHNICAL RIGOR WEIGHT9 / 10

Inheriting OAuth tokens, incremental CDC indexing with Airflow/dbt, and running self-hosted vLLM inside air-gapped private subnets.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 1710 lessons

Enterprise Identity: SSO, OAuth2 & RBAC

Who the user is, what they may reach, how the agent inherits identity, and compliance audit logs.

Core Takeaways:
  • •SSO with Okta, Azure AD (Entra ID), and Google Workspace
  • •Passing JWT claims into LLM and retrieval context
  • •Role-Based Access Control (RBAC) and Row-Level Security (RLS)
ROI: Instant approval from IT security teams by respecting existing company permissions.
WEEK 1813 lessons

Enterprise Connectors & Incremental ETL

Pulling data out of SharePoint, Salesforce, SAP, Jira, and S3, and incremental index sync.

Core Takeaways:
  • •Enterprise data connectors (SharePoint, Google Drive, Salesforce, Jira)
  • •Change Data Capture (CDC) and incremental index refreshes
  • •Deleting removed documents and updating stale embeddings
ROI: AI that stays automatically synchronized with live company knowledge bases.
WEEK 1912 lessons

Security Frameworks: SOC2, GDPR & HIPAA

Prompt injection defense, data loss prevention (DLP), and answering vendor security questionnaires.

Core Takeaways:
  • •Answering enterprise Vendor Security Questionnaires (VSQ)
  • •SOC 2 Type II, GDPR, EU AI Act, and HIPAA requirements for LLMs
  • •Data Loss Prevention (DLP): detecting API keys, credit cards, SSNs
ROI: Unblocking 6-figure enterprise procurement contracts that are stuck in legal review.
WEEK 2011 lessons

Private VPCs & Self-Hosted Models with vLLM

Deploying open-weight models (Llama 3, Qwen) inside private subnets without public internet egress.

Core Takeaways:
  • •Serving open-weight models with vLLM behind an OpenAI-compatible API
  • •GPU sizing, tensor parallelism, and PagedAttention memory optimization
  • •Air-gapped and on-premise container deployment architectures
ROI: Winning government, defense, and banking clients who forbid third-party API calls.
MONTH 5 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

Secure Enterprise Copilot with RBAC & Private VPC

Build a multi-department enterprise assistant that inherits user SSO identity, enforces Role-Based Access Control (RBAC) on document search (HR cannot see engineering salaries), logs audit trails, and falls back to self-hosted vLLM inside a private VPC.

Client Engagement Scenario:

Healthcare company needs clinical staff to search patient protocol documents with strict HIPAA logging and zero data egress to public APIs.

Target Business KPI:

Zero permission leaks across 1,000 synthetic multi-role test queries; 100% compliance pass.

Stack:PythonFastAPIvLLMQdrant ACLOAuth2Docker
Stage Frameworks:OAuth2 / OIDCLlamaIndexvLLMAirflowdbtGuardrails AI
STAGE 6 // MONTH 6+1120 XPUnlocks: Forward Deployed Master

The FDE Craft: Discovery, Delivery & Capstone

Own the consulting craft: discovery, SOW scoping, change management, and client presentation.

This is what separates a pure coder from a Forward Deployed Engineer. Week 1 is stakeholder discovery & ROI mapping; week 2 the delivery playbook with a complete real-world insurance case study (NovaSure Claims); week 3 executive updates, managing scope creep, and team handover; week 4 interview loops and portfolio packaging. The capstone is a complete end-to-end client engagement.

CLIENT IMPACT WEIGHT10 / 10

The best model in the world fails if the client's team doesn't adopt it. The consulting craft is what creates business ROI.

TECHNICAL RIGOR WEIGHT8 / 10

Clear documentation, runbooks, architecture diagrams, and clean code handovers that clients can run after you leave.

WEEKLY CURRICULUM MODULES (4 WEEKS)
WEEK 2110 lessons

Discovery, Scoping & The KPI that Matters

Stakeholder interviews, process mapping, finding the high-value bottleneck, and drafting a crisp SOW.

Core Takeaways:
  • •Conducting stakeholder discovery interviews with department heads
  • •Process mapping: identifying high-friction manual bottlenecks
  • •Selecting the ONE metric that matters (processing time, error rate, cost)
ROI: Aligning expectations so the client agrees on what success looks like on day one.
WEEK 2212 lessons

Case Study: NovaSure Insurance Claims

A complete engagement at an insurer: discovery, 6-page SOW, claims assistant, and POC -> Pilot -> Prod gates.

Core Takeaways:
  • •Deep dive into the NovaSure claims processing engagement
  • •Managing the POC (Proof of Concept) gate vs Pilot vs Production rollout
  • •Change management: bringing reluctant front-line users along
ROI: Learning from real enterprise battle scars rather than theoretical consulting slides.
WEEK 2310 lessons

Executive Communication & Team Handover

Telling the story of the work to executives, saying no without losing the client, and clean technical handover.

Core Takeaways:
  • •Presenting results to non-technical C-suite executives
  • •Handling scope creep: saying 'no, but here is what we can do'
  • •Writing comprehensive handover documentation and runbooks
ROI: Ensuring the AI system continues delivering value long after the engagement concludes.
WEEK 248 lessons

FDE Portfolio Packaging & Technical Interview Loops

Packaging your 6 capstones, preparing for FDE case study interview rounds, and salary negotiation.

Core Takeaways:
  • •Packaging your 6 capstones into high-converting case studies
  • •Navigating the FDE interview: system design, live coding, and client scenarios
  • •Defending architectural trade-offs to senior engineering panels
ROI: Landing high-impact Forward Deployed Engineer roles at top AI firms, Palantir, scale-ups, and boutiques.
MONTH 6 PORTFOLIO CAPSTONE
VERIFIABLE CLIENT DELIVERABLE

End-to-End Enterprise Client Engagement & Capstone

Select a real industry domain (Healthcare, Insurance, Legal, or Logistics). Execute discovery, draft a 6-page Statement of Work (SOW), build and deploy the working AI system, and deliver an executive presentation deck with ROI calculations and team handover runbooks.

Client Engagement Scenario:

Complete simulation of a 6-week client engagement delivering a verified operational AI system.

Target Business KPI:

Demonstrated business KPI improvement (e.g. 40% time saved, 85% automation rate).

Stack:Full StackLangGraph / RAGCloud DeployExecutive Presentation
Stage Frameworks:Consulting PlaybooksSOW FrameworksNovaSure Case StudyInterview Prep