About this course
The Forward Deployed Engineer programme takes an experienced engineer from the FDE mindset through to a full client simulation: foundations, building AI applications and agents, deploying and governing them, and then delivering in a chosen industry domain.
It sets out every module, every topic, the practice work and the knowledge checkpoints, and it states honestly which topics are hands-on, which are taught conceptually, and which are instructor-led demonstrations because of lab or licensing cost.
What you’ll be able to do
- Work as an embedded FDE: own the outcome inside a client’s environment, team and constraints
- Build production-quality Python services and robust enterprise API integrations
- Build LLM applications hands-on with LangChain, and agentic workflows with LangGraph
- Build and evaluate enterprise retrieval pipelines, and argue prompting vs RAG vs fine-tuning on cost, latency, data and maintenance
- Apply agentic software development with Claude Code under real guardrails and human checkpoints
- Design compliant AI architectures and deploy them hands-on on GCP
- Secure, govern, instrument and cost-manage AI systems in production
- Run discovery and present to non-technical stakeholders honestly
- Deliver an end-to-end simulation in Medtech, BFSI or Manufacturing
Before you start
What this course assumes you can already do.
- Working software engineering experience.
- Comfortable with Python and the command line before module 3.
The curriculum
Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.
Recaps and reference material are included in the LMS.
PART 1Foundations
01FDE Role & Mindset
Internalise the FDE mindset — ownership, adaptability, resourcefulness, and client-first problem solving — and clearly differentiate the FDE role from traditional software engineering roles
- What is a Forward Deployed Engineer: role, mandate, and how it differs from traditional SWE/consulting rolesConcept
- The FDE mindset: ownership & bias for action, comfort with ambiguity, resourcefulness, curiosity, resilience under pressureConcept
- Embedded delivery model: working inside the client's environment, team, and constraintsConcept
- Consultant + Engineer + Product-thinker: balancing business outcomes, technical feasibility, and user needsConcept
- Start-up-within-enterprise mentality: rapid prototyping, 'ship, learn, iterate', pragmatic trade-offs over perfectionConcept
- Client-facing competencies: communication, active listening, executive presence, and professionalismConcept
- Building trust and credibility: managing expectations, transparent status reporting, handling pushbackConcept
- Cross-functional collaboration: working with sales, delivery leads, client stakeholders, and internal engineeringConcept
- Anthropic / vendor ecosystem and competitive landscape overviewConcept
- Day-in-the-life case studies and real FDE engagement walkthroughsConcept
Write your own FDE role boundary
Pick one engagement shape you have seen or read about and write a one-page note that separates what an FDE owns from what the client team owns.
Knowledge checkpoint with explained answers
02AI-Assisted Development Foundations
Set up and use an AI coding assistant effectively and responsibly to speed up hands-on development in later modules
- Using natural-language prompts and an AI coding assistant to generate, iterate, and refine codeHands-on
- Setting up and working with an AI coding assistant (e.g., Claude Code) for everyday development tasksHands-on
- Effective practices: describing intent clearly, iterative refinement, breaking work into small verifiable stepsHands-on
- Guardrails: reviewing and verifying AI-generated code before use; when to trust vs. when to check manuallyHands-on
- Using AI-assisted coding as an accelerator across the hands-on labs in upcoming modules (Tech Stack, LLM Foundations, Prompt Engineering)Hands-on
Verify what the assistant wrote
Take a small task you already know the answer to and drive Claude Code through it: describe the intent, let it draft, then review before you accept anything.
Knowledge checkpoint with explained answers
03Tech Stack — Programming Languages & Foundations
Write production-quality Python and apply foundational data and scripting skills for FDE workflows
- Python for production: type hints, OOP, error handling, logging, testing (pytest)Hands-on
- Python data libraries: NumPy, Pandas, Requests, JSON handlingHands-on
- TypeScript / JavaScript fundamentals for client-facing integrations and UisHands-on
- SQL for data exploration and pipelines: joins, CTEs, window functions, query optimizationHands-on
- Git / GitHub workflows, command-line proficiency (Bash/PowerShell), REST & JSON basicsHands-on
Turn a script into production Python
Start from a working but rough script. Add type hints, real error handling, structured logging and pytest coverage for the paths that can actually fail.
Knowledge checkpoint with explained answers
04Tech Stack — APIs & Enterprise Integration
Design and consume robust APIs and implement enterprise-grade authentication patterns
- REST API design & consumption: retry with exponential backoff, idempotency, rate limiting, timeoutsHands-on
- Enterprise authentication: OAuth 2.0, OIDC, SAML, mTLS, API keys, secrets managementHands-on
- Webhooks: receivers, signature validation, retries and idempotent processingHands-on
- GraphQL fundamentals (good-to-know for modern SaaS / internal tooling)Concept
Make an API client survive a bad day
Build a client for a REST API that handles retry with exponential backoff, idempotency on writes, rate limiting and timeouts — and prove each one with a test that forces the failure.
Knowledge checkpoint with explained answers
05Tech Stack — AI/ML SDKs & App Frameworks
Use leading LLM provider SDKs and app/UI frameworks to build and demo AI-powered applications
- LLM provider SDKs: OpenAI, Anthropic, Google Gemini, Cohere, Hugging Face TransformersHands-on
- App & UI frameworks for AI: FastAPI, Flask, Streamlit, Chainlit, GradioHands-on
- Good-to-know: awareness of the ML library landscape (PyTorch, TensorFlow, scikit-learn) for reading data science team output — not hands-onConcept
One prompt, three SDKs, one demo
Call the same task through two different LLM provider SDKs and note where the request shape, streaming and error handling differ.
Knowledge checkpoint with explained answers
06Tech Stack — Cloud, DevOps & MLOps Tooling
Containerise AI applications and set up CI/CD pipelines for reliable production deployments
- Containerisation with Docker: Dockerfiles, images, Docker Compose, container debuggingHands-on
- Kubernetes & Terraform (Infrastructure-as-Code) — senior / good-to-knowConcept
- CI/CD tooling: GitHub Actions, GitLab CI, Jenkins; secrets management; environment promotionHands-on
Package and pipeline an AI app
Containerise the app from the previous module: a Dockerfile you can defend, a Compose file for its dependencies, and a debugging pass on a container that will not start.
Knowledge checkpoint with explained answers
PART 2Build - AI Apps & Agents
07LLM Foundations & Prompt Engineering for Application Development
Explain core LLM mechanics, decide between RAG, fine-tuning, and agent-based approaches, and build enterprise-grade retrieval pipelines hands-on
- How LLMs work: tokens, embeddings, context window, transformersConcept
- Model comparison (GPT, Claude, Gemini) and selection by taskConcept
- Generative AI limitations, hallucinations, safety & responsible AI in application designConcept
- Prompt engineering: zero-shot, few-shot, chain-of-thought, system prompts, persona/instruction tuningHands-on
- Advanced prompting: ReAct-style reasoning, task decomposition for multi-step workflowsHands-on
- Production prompting: structured outputs, JSON/schema enforcement, prompt versioning and testingHands-on
- Prompt injection risks and mitigationHands-on
- LLM-as-judge: using an LLM to evaluate another LLM's outputHands-on
- Conversation state/memory, streaming responses, basic function/tool callingHands-on
- Lab: build a working LLM application in Python using LangChain + an LLM API — prompting, memory, streaming, tool calling, end to endHands-on
Build the LLM application end to end
Build a working LLM application in Python with LangChain and an LLM API: prompting, conversation memory, streaming responses and basic tool calling.
Knowledge checkpoint with explained answers
08RAG, Fine-Tuning & Model Trade-offs
Build and evaluate a production-grade RAG pipeline using RAGAS and DeepEval, explain when fine-tuning is the right call, and choose between prompting, RAG, and fine-tuning based on cost, latency, and maintenance trade-offs.
- What is RAG? RAG implementationHands-on
- Vector databases hands-on (Pinecone, Weaviate, Qdrant, pgvector, FAISS, Chroma, Milvus): embedding, indexing, similarity searchHands-on
- Enterprise retrieval pipelines: ingestion, chunking, metadata, access controlHands-on
- Hybrid retrieval, filtering, reranking; grounding & citation patternsHands-on
- RAG evaluation with RAGAS and DeepEval: retrieval metrics, answer quality, failure analysisHands-on
- GraphRAG overview (conceptual only)Concept
- Fine-tuning introduction: what it is, when it beats prompting/RAG (conceptual — no hands-on training, lab-cost reasons)Concept
- Model trade-off framework: prompt vs RAG vs fine-tuning — cost, latency, data needs, maintenanceConcept
- Lab: RAG application over enterprise-style content, built on top of Module 7's app, evaluated with RAGAS/DeepEvalHands-on
Add retrieval, then measure it
Extend the module 7 application with real retrieval: ingest enterprise-style content, chunk it, carry metadata and access control, then index it in a vector database and add hybrid retrieval with reranking.
Knowledge checkpoint with explained answers
09Customer Discovery & Solution Framing
Apply discovery frameworks to convert business problems into AI problem statements and quantify value
- Discovery frameworks, listening, scoping and prioritisationConcept
- Converting business problems into AI problem statements; effort vs impact matrixConcept
- ROI modelling, KPIs, acceptance criteria, value quantificationConcept
- Environment readiness: data landscape, infra constraints, regulatory contextConcept
- Role-play: low-AI-maturity customers and expectation-settingConcept
Turn a business problem into an AI problem statement
Run a discovery conversation against a low-AI-maturity brief. Produce the AI problem statement, an effort-versus-impact placement, the KPIs and acceptance criteria, and an honest read on environment readiness — data, infrastructure and regulatory context.
Knowledge checkpoint with explained answers
10AI System Design & Architecture
Design scalable, compliant AI architectures and make informed build-vs-buy and cloud-platform decisions within lab/licensing constraints
- Enterprise AI architecture patterns (monolith vs modular, stateful vs stateless)Concept
- Buy-vs-build frameworks; decision matricesConcept
- Cloud deployment patterns — hands-on on GCP; AWS & Azure covered as theoretical/architecture overview only (multi-cloud comparison, no hands-on licensing cost)Hands-on
- Legacy system integration and restricted network architecturesConcept
- Data residency, sovereignty and cross-border complianceConcept
Architect it, then justify the platform
Produce an architecture for the solution you framed in module 9: monolith or modular, stateful or stateless, buy or build, and how it reaches the legacy systems behind a restricted network.
Knowledge checkpoint with explained answers
11Agents, Frameworks & Protocols
Build and orchestrate AI agents hands-on with LangGraph, understand the broader framework landscape (CrewAI, AutoGen, LlamaIndex, Bedrock Agents), and apply standard agent protocols
- Agent fundamentals: planning, memory, tool use, multi-step reasoningConcept
- Hands-on deep-dive: LangGraph for building and orchestrating agentic workflows (builds on the LangChain basics from Module 7)Hands-on
- Framework landscape overview (conceptual, not hands-on): CrewAI, AutoGen, LlamaIndex, and other multi-agent frameworksConcept
- Bedrock Agents — instructor-led demonstration only (lab/licensing cost constraint, not a learner exercise)Demonstration
- Agentic workflows, orchestration, and multi-agent collaboration patternsHands-on
- Agent protocols: MCP (Model Context Protocol), A2AHands-on
- Function calling / tool use APIsHands-on
Orchestrate a multi-step agent
Build an agentic workflow in LangGraph on top of your LangChain work: planning, memory, tool use and a multi-step path with a checkpoint a human can interrupt.
Knowledge checkpoint with explained answers
12Agentic Software Development
Apply agentic software development practices hands-on with one AI coding agent, compare it against alternative tools, and plan, build, test, and ship production code while maintaining quality and governance
- Agentic SDLC: hands-on with one AI coding agent (Claude Code) for spec-to-code workflows; feature/approach comparison against GitHub Copilot and Cursor (demo/comparison only, not hands-on)Hands-on
- Spec-driven & prompt-driven development: writing specs, task decomposition for agentsHands-on
- Agentic code review, testing & verification; guardrails and human-in-the-loop checkpointsHands-on
- Autonomous debugging, refactoring, and test generation using agentsHands-on
- Agentic CI/CD: agents in build/test/deploy pipelinesHands-on
- Best practices, limitations & responsible use of agentic dev tools in client environmentsConcept
Ship a feature with an agent in the loop
Take a real feature from spec to merged code using Claude Code: write the spec, decompose it into tasks an agent can execute, then review what comes back with guardrails you decided in advance.
Knowledge checkpoint with explained answers
PART 3Deploy & Govern
13Integration, Deployment & MLOps
Integrate AI applications with enterprise systems, apply a validate-before-deploy workflow, and deploy using cloud-native patterns within lab/licensing constraints
- Applying API integration patterns (from Module 4) to connect AI services to enterprise systemsHands-on
- Build → Validate/Test → Deploy sequence: staging and pre-deployment validation gates before pushing to productionHands-on
- Cloud deployment: hands-on on GCP Cloud Run/Cloud Functions; AWS Lambda/API Gateway, Azure Functions, and Azure AI Foundry covered theoretically only (licensing/cost constraint — architecture walkthroughs, no hands-on labs)Hands-on
- Connecting to enterprise data (SQL, NoSQL, SharePoint, Confluence, ERP APIs)Hands-on
- Applying containerisation and CI/CD practices (from Module 6) to AI application deployment pipelinesHands-on
- On-prem and VPC integration considerationsConcept
Validate before you deploy
Integrate the application with an enterprise data source, then run the sequence properly: build, validate in staging against real pre-deployment gates, then deploy to GCP Cloud Run or Cloud Functions.
Knowledge checkpoint with explained answers
14Security, Privacy & Responsible AI
Apply security best practices, handle regulated data, and implement responsible AI governance
- OWASP Top 10 for LLMs; prompt injection, data leakage, secure API designHands-on
- PII / PHI handling, GDPR, HIPAA, audit loggingConcept
- Responsible AI: fairness, bias detection, transparency, model cardsConcept
- Red-teaming and threat modelling for AIHands-on
- AI governance frameworks (EU AI Act, NIST AI RMF) and model auditingConcept
Red-team your own application
Threat-model the application you built, then attack it against the OWASP Top 10 for LLM Applications — prompt injection, data leakage, insecure output handling — and fix what you find.
Knowledge checkpoint with explained answers
15Monitoring, Observability & Cost
Implement observability for AI systems, evaluate output quality, and manage operational costs
- AI observability fundamentals; logging inputs and outputsHands-on
- Tooling: LangSmith, LangFuse, LangWatch tracingHands-on
- Evaluation frameworks (automatic + human-in-the-loop)Hands-on
- Drift detection, reliability testing, issue triageHands-on
- Token & cost tracking, latency monitoringHands-on
- Troubleshooting playbooks: latency, hallucination, retrieval failuresHands-on
Instrument it for on-call
Add tracing with LangSmith or Langfuse, log inputs and outputs with a retention story you can defend, and set up token, cost and latency tracking.
Knowledge checkpoint with explained answers
PART 4Client & Specialisation
16Client Delivery & Stakeholder Management
Communicate AI solutions to non-technical stakeholders and manage client relationships through the delivery lifecycle
- Communicating AI capabilities and limitations to non-technical audiencesConcept
- Stakeholder management, change management, adoption strategiesConcept
- Objection handling, expectation setting, risk managementConcept
- Front-end for agents (Streamlit, Chainlit) and exposing agents as chat APIsHands-on
- Value realisation, expansion strategies, lessons-learnedConcept
Present it to someone non-technical
Build a front end for your agent in Streamlit or Chainlit and expose it as a chat API, then present the solution to a non-technical audience — capabilities and limitations, honestly, including the parts that do not sound impressive.
Knowledge checkpoint with explained answers
17Specialised Track — Domain Expertise
Apply AI solutions within the context of specific industry domains, compliance requirements, and consultancy approaches
- Domain overview - Medtach, BFSI, Manufacturing.Concept
- AI opportunities in the mentioned domainsConcept
- Enterprise data for specific domainsConcept
- ComplianceConcept
- Understanding the consultancy approachConcept
- Problem Solving.Hands-on
Go deep on your chosen domain
Choose Medtech, BFSI or Manufacturing and work the domain properly: the AI use cases that recur, the shape of the enterprise data, and the compliance requirements that decide what can be built at all.
Knowledge checkpoint with explained answers
18Capstone
Demonstrate full FDE competency by completing a real-world simulation from discovery through deployment and presentation
- End-to-end FDE simulation: discovery → architecture → build → deploy → presentHands-on
- Peer / instructor reviewConcept
- Choose the specific domain as per the role.Concept
Run the simulation as an engagement
The capstone is the practice. Work the six milestones in order — discovery, architecture, build, validation, deploy, present — in the domain you chose in module 17.
Knowledge checkpoint with explained answers
FDE capstone simulation
An end-to-end simulation of a real, if compressed, engagement in the domain selected in module 17. Peer and instructor review run alongside the milestones.
Discovery — Run discovery against the domain brief and convert it into a scoped AI problem statement.
Architecture — Design the solution and justify the platform decisions, including the ones constrained by cost or licensing.
Build — Build the working application: LLM application, retrieval where it earns its place, and agentic orchestration.
Validation — Evaluate, secure and instrument before deployment is even discussed.
Deploy — Deploy on GCP through a pipeline, with the enterprise integration actually connected.
Present — Present to a non-technical audience: capabilities, limitations, value and what comes next.
Next course
Tell us about yourself or your team and we’ll let you know how and when you can take this course.