Training program / 12 weeks / 24 to 32 hours a week
Add forward deployed engineering skills to the expertise you already have.
For engineers and domain experts in R&D, quality and regulatory, clinical, supply chain, manufacturing, program management, software and digital teams. You already know the work and the customer. This program adds the skills to turn that knowledge into AI and software solutions a client approves.
Five abilities you will build
A1Understand the end-to-end processand spot where automation, AI or software would help
A2Turn problems into requirementsa clear brief, acceptance criteria and a business case
A3Design the solutionpick suitable technology and sketch the architecture
A4Build and prove a POCworking software on realistic data, measured on real cases
A5Present, get approval, hand overdemo to the client, agree next steps, move toward delivery
Before you start: read the basics, set up your machine, then follow your own path in the tutor, which saves your progress to your GitHub journal. The crash course library lists the best free material for every topic, in the order to take it.
AI runs on six layers. Most of the money goes into the bottom layers; most of what makes one company's AI different from another's is built in the top two. That is where the FDE works: choosing a model, then building the agent and observability layers so the client gets AI that fits, is safe, costs as little as possible, can be maintained and does what it was set up to do.
Observabilitywatch, evaluate, governFDE builds here
Records every step the system takes, scores the quality of its answers, catches problems before users do, and keeps the audit trail a regulator or an unhappy customer will ask for. Small layer, big consequences.
The logic around the model: routing, tools and their permissions, memory, retrieval, approvals and the loop that turns a model into something that does real work. Where the client's solution actually lives.
Claude Agent SDK, OpenAI Agents SDK, Google ADK, LangGraph, Microsoft Agent Framework, MCP
Modelweights and inferenceFDE chooses here
The models themselves, plus the serving that turns them into answers at a price per token. Changes fastest and gets cheaper fastest.
Anthropic, OpenAI, Google, Meta, Mistral, DeepSeek, Qwen; served by them or by clouds and hosts
Computewho runs the machines
Buys the chips, builds the data centers and rents capacity by the hour, or runs it privately. Where most of the money is spent.
AWS, Microsoft Azure, Google Cloud, Oracle Cloud, CoreWeave, your own data center
Siliconwho makes the chips
Designs and manufactures the processors, memory and networking that everything else runs on. The hardest layer to enter.
NVIDIA, AMD, TSMC, Samsung, SK Hynix, Micron; in-house chips such as Google TPU and AWS Trainium
Energypower, grid, cooling
Electricity, transmission and cooling for data centers. Now a real limit on how fast the rest can grow.
Utilities and grid operators, power generators
What the FDE does across those layers
Find the real jobThe process, the bottleneck, the measure
Choose a suitable modelModel layer: right size for each step
Build the agent layerCode, tools, data access, human approval
Secure itLeast privilege, PII, injection, audit
Keep cost downSmaller models, caching, batching
Observe and evaluateTraces, evals, alerts, drift
Hand over to maintainRunbook, owner, support model
The FDE does not train models or run data centers. They pick the right model and build, secure, measure and hand over the layers on top.
The FDE goal
SuitableThe right kind of AI for this job, or no AI where rules do better
SecureClient data protected, access limited, every action traceable
Least costSmallest model and fewest calls that still meet the measure
MaintainableSomeone else can run, fix and change it after you leave
Does the jobMeasured against the outcome it was set up to deliver
The FDE loop
Every engagement, and every module in this program, follows the same loop: from "how does this work actually happen" to "a running solution the owner trusts".
EmbedJoin the client team, meet the process owner and the people doing the work.
DiscoverInterview, shadow, read documents and data; map the real process.
FrameWrite the problem, the success measure and the business case.
DesignLay out two or three options and recommend one.
BuildShip a POC on realistic data with AI coding assistants.
EvaluateTest on real cases; fix what fails; set human review.
Demo and hand overShow the value, agree the next step, leave a runbook.
Who it is for
Track A
Software and digital background
You can build. The program adds domain and business analysis, discovery, product ownership and communication. Fast-track Module 3 after a skills check.
Track B
Domain background
R&D, quality, regulatory, clinical, supply chain, manufacturing or operations. You know the work. The program adds code basics, APIs, data, AI-assisted building and deployment. Fast-track Module 4 after a skills check.
Learners work in mixed pairs, one from each track, so they teach each other and finish the final project together.
Program map
Each module builds one or more of the five abilities, ends with something you hand in, and has a defined check. Follow a row to see where an ability is built and how it is proven.
Three layers of evidence, so a learner, a mentor and a manager can all see the same progress.
1. Every step: the GitHub journal
In the tutor, each of the 13 steps saves evidence to the learner's own GitHub repository and must pass defined checks. A manager opens one link to see what is done.
2. Checkpoints with a mentor
Week 2: knowledge check on LLM concepts and a prompt log review
Week 4: track skills check: a small coding task (domain track) or an industry brief (software track)
Week 6: recorded discovery role-play with a mock client
Week 10: POC demo with evaluation results
Week 12: final review panel: demo, questions, hand-over pack
3. Rubric and graduation
The panel scores seven dimensions as not yet, practitioner or FDE-ready. To graduate: FDE-ready in discovery, build quality, evaluation and safety, and communication, and at least practitioner in the rest.
See the full rubric
Dimension
Not yet
Practitioner
FDE-ready
Discovery
Asked mostly about features or opinions; process map has gaps.
Captured the real process and pain from the last real cases; map is complete.
Found the root problem and the hidden constraint; the client recognizes the map as their work.
Problem framing and value
Success is a feature list.
Success is a measurable outcome with a baseline.
Business case is sized, credible and agreed by the process owner.
Solution options
One option, no trade-offs.
Two or three options with clear pros, cons and costs.
Recommendation is defensible on accuracy, cost, risk and adoption; knows when not to use AI.
Build quality
Works only on the demo case.
Works on realistic data; code is readable and runs from the README.
Clean, small, testable; another person can extend it in a day.
Evaluation and safety
No test set.
30+ cases, a pass rate and the top failures explained.
Evaluation drives changes; human review and access limits match the risk.
Deployment and operations
Runs only on a laptop.
Deployed behind access control with secrets handled properly.
Tracing, cost tracking and a runbook; someone else could operate it.
Communication
Demo is a tour of features.
Demo starts from the client problem and shows real results.
Handles hard questions calmly; states limits honestly; next step is agreed.
Choose a project to practice on
Pick a project from the industry you know or want to work in. You build it in the final two weeks, from discovery to demo. Filter by industry below, or find 86 more ideas in your path.
Industry:
Core
1. Invoice exception handling
Finance operations
Client
Accounts payable lead at a mid-size distributor. 3,000 supplier invoices a month; about 15% fail matching against purchase orders.
Pain
Clerks chase buyers by email, re-key data and miss early-payment discounts.
Data you get
50 sample invoice PDFs, a purchase order export (CSV), an email thread sample, the AP policy (PDF).
Deliver
Process map of the exception path
Extraction of invoice fields into JSON with a match check
Drafted exception summary and suggested resolution for a clerk to approve
Evaluation on 30+ invoices: extraction accuracy and correct routing
Tests: Document AI, rules plus LLM, human approval, business case
Core
2. Support ticket triage and reply drafting
Customer service
Client
Head of support at a software company. 1,200 tickets a week across email and chat.
Pain
Tickets sit unassigned; agents answer the same questions from scratch.
Data you get
500 anonymized tickets with categories, a help-center export, an SLA policy.
Deliver
Category and priority classifier with confidence
Reply drafts grounded in help articles, with citations
Routing rules and an escalation path
Evaluation: classification accuracy, groundedness of replies
Software track, advanced. Building LLM applications on a data platform.
Proctored exam
Track A
How it runs
Every week follows the same rhythm, so learners always know what is expected and when. Read each lane left to right: it shows who does what across the week.
A typical week
Learner
Pair
Mentor
Mock client
Reviewer
1
2
3
4
5
6
7
8
Mon: self-study, videos, reading
Tue: live session, worked example
Wed: build the week's hand-in
Wed-Thu: office hours, unblock
Thu: answers questions as client
Thu: commit evidence to journal
Fri: show and tell to the group
Fri: score on rubric, feedback
Learner: Mon: self-study, videos, reading
Mentor: Tue: live session, worked example
Pair: Wed: build the week's hand-in
Mentor: Wed-Thu: office hours, unblock
Mock client: Thu: answers questions as client
Learner: Thu: commit evidence to journal
Pair: Fri: show and tell to the group
Reviewer: Fri: score on rubric, feedback
Mock clients join in discovery, demo and final project weeks. Everything a learner hands in is committed to their GitHub journal, so progress is visible to the mentor. On smaller screens, scroll sideways to see every step.
Principles
Learn by doing: every week ends with something handed in and committed
Real material: messy documents, realistic data, real constraints
AI as tutor and tool: use it to explain, draft and code, then show your own reasoning
Evidence over opinion: every claim backed by an interview, a document or data
Feedback every week from a mentor and from peers
Who runs it
Program lead: owns cohorts, the plan and graduation decisions
Mentors: experienced engineers and consultants, one per four to six learners
Mock clients: domain experts who play the client in discovery, demos and the final project
Reviewers: score hand-ins and the final project against the rubric
Tools learners use, in the order they need them
Think and draftClaude, ChatGPT or Gemini
BuildClaude Code, Cursor or Copilot; Python; Git
ConnectAPIs, MCP servers, n8n
EvaluateA test set; tracing with Langfuse
DeployCloudflare, AWS, Azure or Google Cloud
ShowDiagrams, a recording, a live demo
Learners pick one tool per stage to start; the program does not depend on any single vendor.