Contents Start here
Start here
Introduction: what this forward deployed engineer course builds, and how to use it
The whole course told through one customer, Bramfield Mutual, from the first call to the day its claims team uses the system without you.
Free lesson
About 57 minutes to read.
Your progress0 of 7 checks answered right
It fills only when a prediction matches the measured result. Reading a page does not move it. It is kept in this browser.
Become a Forward Deployed Engineer: Ship AI for Real Customers. Start here.
This course teaches the job of a forward deployed engineer by doing it once, slowly, for one customer. A forward deployed engineer is a software engineer who works directly with one customer, inside that customer's own systems, until a piece of software really does the job the customer needs, and the customer's own people can run it. Our customer is an insurance company called Bramfield Mutual. You will follow it from the first phone call, where its head of claims asks for "AI for claims", to the day its claims team uses what you built without you in the room. This lesson tells that whole story in plain words, shows you the real systems and the real numbers you will start from, explains how the course is laid out, and tells you what you need before you begin.
After this lesson you will be able to:
- say in plain words what this course builds, and for which customer;
- explain why Bramfield Mutual is fictional, and how the course makes sure none of its records can belong to a real person or a real car;
- tell the story of the engagement in order: the request, the real problem, the old systems, the pilot, the proof, production and the handover;
- read the baseline we measured on Bramfield's claims database, and say why a project needs that number before it starts;
- name the eight parts of the course, and the skills from 41 real job postings that each part teaches;
- use a lesson of this course well, and say what a lesson's lab costs while it runs.

What you need first: nothing. This is a reading lesson with a knowledge check at the end. There is no code to run and nothing to build.
Time: about 35 to 40 minutes.
What it costs: nothing. This lesson starts no cloud resources.
Dates and times: every time in this lesson is in UTC, the world's reference clock. The terminal output and the screenshots in this lesson come from the lab run of the lesson "Meet Bramfield Mutual, the customer in this course", on 13 November 2026 between 07:58 and 08:03 UTC, which was 13:28 to 13:33 in the afternoon where we work, in India. The job postings were read on the same day.

The problem: "We want AI for claims", and nobody has said what that means
Picture the head of claims at a medium-sized car and home insurer. A claim is a customer's request to be paid for a loss, such as a cracked windshield or a car damaged by hail. Her team of adjusters, the people who check each claim against the policy and decide what to pay, takes about three weeks to settle a simple one. The pile of open claims grows after every winter storm and every hail season. Last week she watched a demonstration in which an AI model read a claim file and wrote a sensible summary in a few seconds. So she calls you, and she says the sentence that starts most of these projects: "We want AI for claims."
The demonstration was real, but it was easy. Someone picked clean examples and typed them in. Her team's real work lives somewhere else: in an old database whose dates are written in two different ways, in files that other companies' systems drop on a server at two o'clock every morning, in a policy service built many years ago that answers one page at a time, and in scanned forms. Around all of that are people. The adjusters would have to trust the new tool. The security team has a long questionnaire. And the law says a great deal about what may be done with a customer's personal data. None of that was in the demonstration.
Someone has to close the distance between "the model did it in a demo" and "the claims team uses it every morning and trusts it". OpenAI calls that distance "the deployment gap", and the person who closes it for one customer at a time is the forward deployed engineer. This course is about that work. The lesson "What a forward deployed engineer does" reads how Palantir, OpenAI, Salesforce and Ramp describe the job in their own words.
Words for this lesson
These words come back all through the course. Each one has an everyday picture to hold on to.
| Word | What it means, plainly | An everyday comparison |
|---|---|---|
| claim | a customer's request to be paid for a loss, such as a cracked windshield | handing in a receipt and asking to be paid back |
| adjuster | the person who checks a claim against the policy and decides what to pay | the shop assistant who checks your receipt before giving a refund |
| engagement | one piece of work for one customer, from the first meeting to the end | one building job, from the first site visit to handing over the keys |
| baseline | how things are measured today, before you change anything | stepping on the scale before a diet, so you can show the change later |
| synthetic data | records made up by a program, describing no real person | the play money in a board game: it works in the game and buys nothing outside |
| pilot | a small, real trial with an agreed scope and an agreed way to measure it | a new bus route run for one month on one street before the whole city |
| handover | the point where the customer's own team runs the system without you | a driving instructor taking their hands off the wheel for good |
The customer in this course: Bramfield Mutual, a fictional insurer
Idea: The customer is invented, every record is made up, and the made-up records are built so that none of them can ever belong to a real person.
Think of the patients that medical students practise on: actors, trained to describe symptoms that are not their own. They are real enough to learn from, and nobody's private records are at risk. The customer in every lesson of this course is Bramfield Mutual Insurance Company. Before anything else, you should know this clearly: Bramfield Mutual is fictional. It does not exist, and any likeness to a real company is an accident. Everything about it below is invented for the course:
- It is a property and casualty insurer, which means it insures things people own, such as cars and homes, against loss and damage.
- It is a mutual: it is owned by its policyholders rather than by shareholders.
- It was founded in 1962 and has its head office in Harrisburg, Pennsylvania, with about 2,800 staff.
- It sells personal car insurance and homeowners insurance in 11 states, including California, mostly through independent agents.
- It collects about $1.1 billion a year in premiums, the money customers pay for their policies. It is profitable, but slow.
We checked that the name is not used by a real insurer before we chose it. A web search found only English villages called Bramfield, the US Securities and Exchange Commission's company search found no company of that name, and the obvious web addresses for it are not registered.
Every record is synthetic, and none can be real
Bramfield's systems hold a great deal of data, and every record in them is synthetic: made by the course's own generator program, from a fixed starting number, so that everyone who builds the lab gets the same data. No real person's data is used anywhere. Because the course teaches you to find and protect personal data, the generator does plant things that look like personal data in the claim notes: names, phone numbers, addresses, Social Security numbers, driver's license numbers and vehicle identification numbers. So it also makes sure that none of them can ever belong to a real person or a real car:
- Social Security numbers. A US Social Security number has three parts: the area number, the group number and the serial number. Every number the generator writes uses group number 00, the fourth and fifth digits. The Social Security Administration says it "will not assign group number 00 or serial number 0000", so these numbers can never have been issued. The generator also avoids the area numbers 000, 666 and 900 to 999.
- Vehicle identification numbers (VINs). The ninth character of a North American VIN is a check digit, calculated from the other sixteen. The generator writes a deliberately wrong check digit, so no VIN in the data can match a real vehicle.
- Phone numbers. Every phone number is in the range 555-0100 to 555-0199, which the North American Numbering Plan Administrator keeps for made-up numbers in films, television and advertising.
- Policy and claim numbers use course-only prefixes,
BMQfor policies andCLQfor claims, with a check digit of our own design. - Every row carries a flag,
SYNTHETIC = true.
There is a lesson hidden in the first rule. A tool that hides personal data by looking only for valid Social Security numbers will skip every one of these, because group 00 is invalid. The lesson "Finding and masking personal data before the model sees it" will test for exactly that mistake.
Watch out: synthetic is not the same as masked. Synthetic data was never real. Masked data was real, and someone hid the personal parts. A tool tested only on Bramfield's invalid numbers has not yet been tested on real ones.
A tool that hides personal data finds Social Security numbers by checking that each one could really have been issued. What does it do with the numbers in Bramfield's claim notes?
Show the answer
The answer: B.
Every number the generator writes uses group 00, and the Social Security Administration says it "will not assign group number 00", so a tool that looks only for numbers that could be real finds none of them and hides nothing. C is wrong because the generator avoids the area numbers 900 to 999. The lesson "Finding and masking personal data before the model sees it" tests for exactly this mistake.
Why it matters: a demo is easy, and a working system is the job
Idea: A demo shows that a model can talk; the job is to make a system the customer's team uses every day and trusts.
A cooking show makes a meal look easy, because the vegetables were chopped before the cameras rolled. Running a restaurant kitchen every night is a different job. Many companies now hire forward deployed engineers. On 13 November 2026 we read the public job boards of 19 companies that hire them and found 336 open roles with "forward deployed", "FDE" or "deployment strategist" in the title. We kept 41 of those postings, from 18 companies, to study closely. Those postings ask for the whole journey from the first meeting to a system in daily use, not for a clever demo. The skill they mention most is putting software into production and keeping it reliable, in 37 of the 41. Next come owning a vague problem without being told what to do, in 36, scoping and discovery, in 32, and building AI agents, also in 32.
Calling a model is the easy part to learn. This course spends its time on what happens around the model: the first meeting, the measured baseline, the old systems, the personal data, the security review, the proof and the handover. That is the ground every AI project in a real company has to cross before anyone uses it each day, and this course teaches it on systems you build and break yourself.

Read the two columns step by step. On step 4, the demo has nothing to compare against, because nobody measured how long claims took before. The engagement has a number from step 1, so at step 4 it can say whether anything improved. That one difference decides most of what happens later.
Watch out: a room full of impressed people is not evidence. If nobody measured how long claims took before the demo, nobody can say afterwards whether anything got better.
A demo picks ten clean claims and a model summarizes them well. What has it proved?
Show the answer
The answer: B.
The demo shows the model can summarize claims that someone picked and cleaned by hand. It says nothing about how fast real claims settle, because nobody measured that first, and nothing about the old systems, the personal data or the security review. That is why the engagement starts by measuring the 20.4 days.
The idea: one engagement, in order, from the first call to the handover
Idea: Every engagement runs in the same order: find the real problem, get into the systems, run a pilot, prove it, put it into production, and hand it over.
A builder does not put on the roof before the foundations are laid. An engagement is one piece of work for one customer, from the first meeting to the end. This course follows one engagement in the order a real one runs. Here it is in one picture, and then as a story.

Discovery: finding the real problem under the request
Idea: Turn the wish into one problem and one number, before anything is built.
A good doctor does not prescribe because a patient says "I feel bad". They ask where it hurts, and they take a temperature. "We want AI for claims" is a wish, not a problem you can solve. So the first thing you do is ask questions, and the first thing you measure is how things are today. Discovery is that stage: finding out what really hurts, who decides what, and which number would show that things got better. At Bramfield, discovery finds a narrower and much more useful problem than "AI for claims". Simple car claims, such as a cracked windshield or hail damage, take far too long to settle, many of them sit waiting for a supervisor because an adjuster was unsure, and the open pile is large.
Predict, then measure
Bramfield retired four claim status codes in 2009 and 2014. How many of its 6,000 claims do you expect still carry one of them?
The measured result appears once you lock in. Only your first answer counts toward your progress.
A baseline is the measurement of how things are before you change anything. Without it, nobody can say later whether the project helped. We measured the baseline on Bramfield's own claims database, with real SQL, in the lab run of 13 November 2026. Here is that run as it printed in our terminal. The command is make look PART=db, which you will run yourself in the lesson "Meet Bramfield Mutual, the customer in this course":
== the tables you can read, and how many rows each holds
CLMS_ADJUSTER 44 rows
CLMS_CLAIM 6,000 rows
CLMS_NOTE 18,039 rows
CLMS_STATUS_REF 11 rows
== a first query, written the way most people write SQL
error: relation "clms_claim" does not exist
with the name in double quotes: 6,000 claims
== the status codes: what the column holds, and which codes are retired
CLSD Closed in use 3,813
PAID Payment issued in use 1,393
PEND Waiting for documents in use 134
ASGN Assigned to an adjuster in use 117
INVS Under investigation in use 98
SUPV Referred to a supervisor in use 68
NEW Reported, not yet assigned in use 35
CL Closed (retired 2009) RETIRED 264
XX Void (retired 2014) RETIRED 39
OP Open (retired 2009) RETIRED 21
RO Reopened (retired 2014) RETIRED 18
== the loss dates are text, written two ways
YYYY-MM-DD (since 2012) 3,926 for example 2026-01-01
MMDDYYYY (old system) 2,074 for example 01012026
== today's numbers, the baseline the pilot will be judged against
simple claims (glass and hail) settled: 1,480, average 20.4 days from report to close
claims still open: 491; claims ever sent to a supervisor: 35.1%
== is this account really read-only?
error: cannot execute UPDATE in a read-only transaction
Four things in that output matter for the rest of the course.
- The business is invented, and the measurement is real. The generator invented Bramfield's claims, and so it decided, in effect, how slow Bramfield is. But the 20.4 days was not typed by anyone. It came from a real SQL query that converted two kinds of text dates into real dates and averaged the gap between report and close, over 1,480 settled glass and hail claims, on a real PostgreSQL database. That is exactly how you would measure a real customer.
- The very first ordinary query failed. The table names were created in upper case and in double quotes, the way they are often left when a company moves its data off a mainframe, the large central computer that insurers ran for decades, so PostgreSQL will only find them if you quote them too. Small surprises like this are most of the first week at a real customer.
- "Open" and "settled" need careful definitions. The 491 open claims include 21 rows with the retired code OP and 18 with RO, and the 1,480 settled glass and hail claims are counted by their close date, so they include claims closed under the retired codes CL and XX, and XX means void. These codes were retired on paper years ago, yet they sit on claims from 2026, because an old import path still writes them. That is a real day-one finding, and Part 2 will tighten these definitions with the claims lead before the baseline is agreed.
- Your account cannot change anything. The last check tried to change one claim and was refused. You start every engagement with read-only access, and you ask for more only when you can say exactly why.
A worked example: what "20.4 days" really is. The number comes from four plain steps, all done by the query, not by hand.
- Pick the claims that count: glass and hail claims that have a close date. There were 1,480 of them.
- For each one, turn its two text dates into real dates, whichever of the two formats it was written in.
- For each one, subtract: the close date minus the report date gives the days it took. A claim reported on 1 March and closed on 21 March took 20 days.
- Add up all 1,480 of those gaps and divide by 1,480. The average was 20.4 days.
So 20.4 days is an average over 1,480 claims. Some claims took longer and some took less, and an average on its own does not show you that spread.
Watch out: a baseline is only as good as its definitions. "Settled" here includes claims closed under the retired codes
CLandXX, andXXmeans void. Agree each definition with the claims lead before you quote the number to anyone.
The output says 491 claims are still open. Why is that number not ready to quote to Bramfield's executives yet?
Show the answer
The answer: C.
The 491 open claims include 21 rows with the retired code OP and 18 with RO, codes that were retired on paper years ago but are still written by an old import path. Until someone knows what those rows mean, "open" is not defined well enough to quote. Part 2 will tighten these definitions with the claims lead before the baseline is agreed. A is wrong because the claims are invented but the measurement is real SQL on a real database.
Getting into systems you did not build
Idea: The data lives in old systems you did not build, and you go in carefully, with read-only access, through one private door.
A plumber called to an old house does not start by knocking down walls. They look at the pipes that are already there, however strange, and work with them. To build anything useful, you need to read Bramfield's data where it really lives, and almost none of it lives in a tidy modern service. Bramfield's IT team gives you access to five old systems, all of them built for you by the course on one small server in your own AWS account. The server has a public address, so it can download its software, but its firewall accepts no connection from the internet at all. You reach it only through AWS Session Manager, a service that reaches the server from inside AWS, so the server never has to open a port to the internet:
- The claims database, a PostgreSQL 16.6 database, a popular free database, laid out in an old way: upper-case table names, dates stored as text in two formats, and eleven status codes, four of them retired on paper years ago but still written by an old import path onto 342 claims from 2026.
- The policy service, an old SOAP service. SOAP is an older way for programs to call each other, with every request and answer written in XML, a text format that wraps each value in named tags, and a description file called a WSDL that lists what the service can do. It returns 100 policies a page and allows only 10 requests a second.
- The nightly file drop, an SFTP server, which is a server that other systems copy files to securely. Independent agents' systems leave a CSV file, a plain text table with commas between the values, of new claims on it at 2:00 a.m. Eastern time every night, with duplicate rows and amounts written three different ways.
- The documents, 300 claim documents and policy forms as PDFs in an Amazon S3 storage bucket, some of them scanned images with no text inside.
- The sign-in service, Keycloak 26, a real identity provider: the system staff sign in through, standing in for Bramfield's own.
There is also a small work queue, where adjusters pick up the claims assigned to them. Here is what two of these systems did when we looked at them in the same run. First the policy service, with 40 requests sent at the same moment, the way a careless program would send them:
== what the service says it offers (its WSDL)
operations: GetPolicy, GetPolicyPage
== page 1 of the policies
HTTP 200, 100 policies on this page, 200 pages in all, 57,593 bytes of XML
the first one: BMQ-0000001-7, AUTO, WV
== 40 requests sent at the same moment, as a careless loader would
30 x HTTP 200, a page of policies
10 x HTTP 500, a SOAP fault
the fault says: Server.Busy: more than 10 requests a second. Slow down and try again.

Ten of the 40 requests failed with a fault. The service keeps a bucket of 10 tokens that refills at 10 a second, and our 40 requests reached it spread over a couple of seconds, so about 30 found a token and about 10 did not; the split changes a little from run to run. To read all 20,000 policies without breaking the service, you will need to slow down, retry carefully and remember where you stopped. That will be the lesson "Calling an old SOAP API: paging and rate limits".
Watch out: this service says "too many requests" with an HTTP 500, the code that usually means "the server broke". Code that gives up on every 500 will stop a load that only needed to slow down.
Then the file drop:
== the SFTP drop folder, as the agents' systems leave it
agent_claims_export_20261110.csv 12,008 bytes
agent_claims_export_20261111.csv 8,289 bytes
agent_claims_export_20261112.csv 10,211 bytes
== the newest file, agent_claims_export_20261112.csv: its header and first three rows
agent_code,policy_number,loss_date,reported_at,amount_claimed,description
AG0267,BMQ-0010956-0,2026-11-09,2026-11-12T00:02:00-05:00,2020.28 USD,Scraped a pole in a parking garage
AG0107,BMQ-0016442-5,2026-11-09,2026-11-12T00:27:00-05:00,5401.93 USD,Rear-ended at a stop light
AG0438,BMQ-0003477-3,2026-11-06,2026-11-12T00:26:00-05:00,"$2,100.73",Cracked windshield
106 rows, 4 of them exact duplicates; amounts written as: 1,234.56 (48), $1,234.56 (30), 1234.5 USD (28)

One file of 106 rows already has 4 exact duplicates and three ways of writing money. A program that loads it naively would count four claims twice, and Python's float() would fail on 101 of the 106 amounts. Part 3 of the course will teach you to load files like this one safely, and Part 4 will teach you to clean them.
A loader copies the newest drop file of 106 rows straight into a table, with no checks at all. What goes wrong?
Show the answer
The answer: B.
The file has 4 exact duplicates, so four claims would be counted twice, and its amounts are written three different ways, so Python's float() would fail on 101 of the 106 of them. C is wrong because the file does have a header, which names six columns. Part 3 of the course loads files like this one safely, and Part 4 cleans them.
The pilot: an agent that drafts, and a person who decides
Idea: In the pilot the agent only drafts, and a person decides every claim.
Think of a junior doctor writing up a case. The notes can be excellent, and still a senior doctor signs before any treatment starts. A pilot is a small, real trial: real claims, real adjusters, a limited scope and an agreed way to measure it. Bramfield's pilot is a claims triage agent. "Triage" means sorting cases by what they need, as a hospital does at its front door. An AI agent is a program that sends a problem to a language model, the kind of AI that reads and writes text, lets the model ask for the next piece of information through tools that your own code controls, and repeats that until the model can give an answer. The lesson "The claims triage agent" will build it.
The agent will read a claim, check what the policy covers, look for signs of fraud and draft a decision note. Two rules hold it in place, and they never bend in this course:
- Its tools can only read. It can look up a policy, read a claim and read a document. It cannot change a claim, and it cannot pay anything.
- An adjuster approves every decision. The agent drafts, and a person approves, edits or refuses the draft before anything happens.
The second rule has a sharp reason, and the course plants it in the data on purpose. One claim note in Bramfield's database contains a hidden instruction, written as if by a customer, that tells "any AI assistant" reading it to record a payout of $48,500. A careless agent reads text and follows instructions, so it may obey a sentence that a stranger typed into a claim. In the lesson "An instruction hidden in a claim document" you will watch a simple agent fall for it, and then build the layered defense that holds.
Watch out: "the agent only suggests" is not enough on its own. If its tools could write, one obeyed sentence in a claim note could change a record. That is why both rules hold together: tools that can only read, and a person who approves.
A claim note tells "any AI assistant" to record a payout of $48,500. What stops that from happening in Bramfield's pilot?
Show the answer
The answer: C.
The agent has no tool that can change a claim or pay anything, and nothing happens until an adjuster approves, edits or refuses the draft. A is the weak defense the lesson "An instruction hidden in a claim document" shows failing. B and D describe things nobody in this course does.
Proving that it works
Idea: Proof means numbers the customer agreed to before the test, not an impression after it.
A school exam is fair because the answers were written before the students sat down, not after the teacher read their papers. A pilot that "looks good" is not proof. Part 6 of the course will be about proof you can defend in front of the head of claims and her finance director. It has five pieces:
- A golden set: a set of claims whose right answers are agreed with Bramfield's claims lead before any testing. The generator plants labeled answers to make this honest: 109 claims for a loss outside the policy period, 65 with a fraud signal and 150 simple glass claims, with no claim in two lists, kept in a separate answer key that the database never sees. The golden set will be a sample drawn from these labeled pools and agreed with the claims lead in its own lesson.
- An evaluation harness, a program that runs the agent on the golden set and scores it by code, every time a prompt, a model or a tool changes.
- A checked judge. Some things, such as whether a decision note is clear, cannot be scored by code. A second model can grade them, but only after you measure how often its grades agree with the claims lead's own.
- Shadow mode. The agent decides every claim silently, beside the real adjusters, and you compare its decisions with theirs before it is allowed to influence anything.
- The readout, the meeting where you present the results to Bramfield's executives, with the cost in dollars, the savings in dollars and the failures stated plainly.
Watch out: never let a second model grade the agent until you have measured how often its grades agree with the claims lead's own. An unchecked judge just adds a second guess to the first one.
Why are the golden set's right answers agreed with the claims lead before any testing starts?
Show the answer
The answer: B.
Answers fixed before the test are like an exam's answers written before the students sit down: nobody can bend them to match the agent. A is wrong because the harness runs every time a prompt, a model or a tool changes. D is the opposite of the rule: the answer key is kept out of the database the agent can read.
Production inside the customer's walls
Idea: Production means the customer's account, the customer's rules, and evidence for every answer on the security form.
Moving from a pilot to production is like moving a food stall into a hospital canteen. The food may be the same, but now the hospital's hygiene rules, inspectors and paperwork apply. If the proof holds, the system moves into production: real daily use, in Bramfield's own AWS account, under Bramfield's own rules. Its security team has requests that are normal for an insurer. Customer data stays in US AWS regions. Every call out to the internet goes through the company's proxy, a gateway server that checks and logs that traffic. No outside supplier gets shell access, which means a command line on the production servers. And the model provider must not keep Bramfield's data or train on it. Then comes the security review, a long vendor questionnaire answered with evidence from your own system, and an audit trail, a record of who did what and when, that a state insurance examiner could read. Part 7 will build all of it.
Watch out: "no shell access" changes how you fix things. You cannot log in to a production server and look around, so the logs, traces and audit trail you build earlier are the only way to see what went wrong.
Bramfield's security team says no outside supplier gets shell access to production. What does that mean for you when something breaks?
Show the answer
The answer: B.
Without a command line on the production servers, what the system records about itself is all you have, so you build that record before you need it. C would break the rule that customer data stays in US AWS regions, and A and D simply break the no-shell rule.
The handover, and the next engagement
Idea: You have finished only when the customer's own team runs the system without you.
A driving instructor's job is done on the day the learner drives alone, not on the day the learner first drives well with the instructor beside them. The work ends when the claims team runs the system without you. Part 8 will train the adjusters and measure real use from the logs, hand Bramfield's team a runbook, the written steps for running the system and fixing it when it breaks, and rehearse one failure with them, and write the field report: what you learned at this customer that the product team should know. Then it will turn the work into a reusable pattern, so the next team starts in days instead of weeks. The course will end with a capstone. After a hailstorm, Bramfield's homeowners claims team asks for the same kind of help, and this time you run discovery, the pilot, the evaluation and the rollout yourself, then tear it all down.
The pilot passed and the system is live in Bramfield's account. When is the engagement finished?
Show the answer
The answer: B.
Going live, presenting the readout and good scores all come before the end. The engagement ends when Bramfield's own people run the system without you, with the runbook to fix it when it breaks.
What you build in this course
Idea: You build the customer's old systems first, then everything on top of them, all in your own AWS account.
All of Bramfield's old systems, and everything you build on top of them, run in your own AWS account. This is the picture you start from:

| What you build | What it is |
|---|---|
| Bramfield's systems | One small server, a t2.small with 1 virtual CPU and 2 GB of memory, running the claims database, the SOAP policy service, the work queue, the SFTP drop and Keycloak, plus the documents in S3. It sits in your own AWS account with a public address but a firewall that accepts no connections from the internet, and it is reached only through AWS Session Manager. One command builds it with Terraform, a tool that creates cloud resources from text files that describe them, and one command removes it. |
| Safe ways in | Code that pages through the SOAP service within its limit, loads the nightly files without duplicates, loads only what changed, writes back without making duplicates, and signs Bramfield's staff in through Keycloak. |
| Clean, safe data | Cleaned claims, personal data masked before any model sees it, a golden set agreed with the claims lead, and a record of where every number came from. |
| The claims triage agent | An agent with read-only tools; Bramfield's systems offered to it through one checked MCP server (MCP is a standard way to hand an AI model a set of tools); an adjuster approving each decision; and a defense against instructions hidden in documents. |
| Honest proof | The evaluation harness, the checked judge, the shadow run and the readout. |
| Production | The system in Bramfield's account, in private networks, with traces that stay inside, a cost line in dollars for every claim, a rollout one state at a time, the security review and the audit trail. |
| The handover | The runbook, the field report, the reusable pattern and the capstone. |
In the picture above, the agent has three red arrows to Bramfield's systems, all labeled reads. Why only reads?
Show the answer
The answer: B.
That is the pilot's first rule: the agent can look up a policy, read a claim and read a document, and it cannot change a claim or pay anything. Anything that happens goes through an adjuster, who approves, edits or refuses the draft.
The course map
Idea: The course follows the engagement in order, and the AI arrives only after you can measure the problem and read the data yourself.
The course is laid out like a book: three lessons called "Start here", then eight parts. The order follows the engagement, and it is deliberate. The AI arrives only in Part 5, after you have measured the problem and can read the data yourself, because an agent you cannot check is an agent nobody should trust with a customer's money.
| Part | What happens at Bramfield |
|---|---|
| Start here | This introduction; "Before you start", which checks your tools and your AWS account; and "Your AWS account and model key, set up safely". |
| Part 1, The job and the customer | What the job is, how it differs from nearby jobs, "Meet Bramfield Mutual, the customer in this course", where you build Bramfield's systems, how an engagement runs, your first day inside systems you did not build, and the working notes that let anyone pick up your account. |
| Part 2, Discovery and scoping | "The first meeting: "we want AI for claims"", the people who matter on the account, "Turning a wish into a number you can measure", whether the data is really there, security and compliance discovery, when the answer is not a model at all, and the written scope of the pilot. |
| Part 3, Getting into the customer's systems | Scoped access instead of global admin, single sign-on through Keycloak, the old SOAP API, the nightly file drop, loading only what changed, writing back without duplicates, private networking, the corporate proxy and its certificate error, and the customer's secrets. |
| Part 4, From messy data to safe data | Cleaning the claims data, a column renamed upstream, finding and masking personal data, reading claim documents, the golden set, and where every number came from. |
| Part 5, The pilot: an AI that does the job | Choosing the model, decisions your code can check, answering from the policy form, better retrieval, safe questions about the data, the claims triage agent, Bramfield's systems as an MCP server for the agent's tools, a person approving every decision, the hidden instruction, and a pilot demo that tells the truth. |
| Part 6, Proving it works | What "it works" means for Bramfield, reading the failures, the evaluation harness, a checked judge, shadow mode and the pilot readout. |
| Part 7, Production inside the customer's walls | Building in the customer's AWS account, private subnets, traces that never leave, cost per claim, when the model provider fails, rolling out to one state first, debugging without a shell, the security review and the audit trail. |
| Part 8, Handover, adoption and the next engagement | Getting the claims team to use it, the runbook and the handover, the field report, the reusable pattern, the expansion proposal, the hailstorm capstone, and your portfolio and the interview. |

Why does the AI arrive only in Part 5 of the course, and not in the first week?
Show the answer
The answer: D.
You first measure the problem and learn to read the data yourself, because an agent you cannot check is an agent nobody should trust with a customer's money. B is wrong because the security review comes in Part 7, after the pilot. C is wrong because 32 of the 41 postings ask for AI agents, one of the most common skills of all.
What the job postings ask for, part by part
We built the course from the jobs, not the other way round. On 13 November 2026 we read 41 forward deployed engineer postings from 18 companies, including Palantir, Databricks, OpenAI, Salesforce, Scale AI and Anthropic, and counted which skills each posting mentions at least once. Every part of the course answers some of those skills:

Two things are worth noticing. First, the skill mentioned most, production deployment and reliability, in 37 of 41 postings, will be taught in Part 7, near the end, because you cannot run something in production before you have built and proved it. Second, a few skills in the postings are not taught here, and we say so plainly: the course uses Python throughout but does not teach TypeScript, front-end frameworks or Kubernetes, and it gives fine-tuning only one section, because only 1 posting in 41 asked for it. Travel to customer sites, asked for in 28 postings, is part of the job but not something a course can teach; the lesson "What a forward deployed engineer does" reads what the postings say about it.
Watch out: "37 of 41" counts postings that mention a skill at least once. It tells you how often employers ask for it, not how much of the job it fills, and 41 postings from 18 companies are a sample, not the whole market.
Production deployment is the skill the postings mention most, in 37 of 41. Why does the course teach it in Part 7, near the end?
Show the answer
The answer: B.
Production comes after the pilot and the proof, because a system goes into daily use only once it works and the customer has agreed it works. D is wrong because the lab runs on AWS from Part 1 onwards.
How every lesson works, and how to use this course
Idea: Every lesson runs like a class: the problem, the why, the idea, the hands-on part, then a check of what you learned.
Every lesson is written to the same plan, the way a teacher runs a class:
- A problem first, as a real moment at Bramfield, in everyday words, before any technical name.
- Why it matters, in plain sentences.
- The idea, with a diagram for every idea that has a shape or an order.
- The hands-on part, on the lesson's own lab: every command in its own box, with the real output it printed in our lab under it, filled in from our terminal recording and never typed. After each important run there is a "what just happened" diagram or paragraph drawn from that run's own numbers.
- A knowledge check, with every answer explained, and a part for working engineers and staff engineers at the end.
A good way to work through a lesson:
- Read the story and the idea first, with the diagrams, before you touch the keyboard.
- Then download the lesson's zip, if it has one. The link is at the top. This lesson has no code, so it has no zip. A zip holds a
START-HERE.mdfile with every step and its expected output, the code, the diagrams and the lesson as a PDF. - Compare your output with ours. Times, identifiers and AI answers differ a little from run to run, but the shape of the output should match. If something else differs, each lab lesson has a troubleshooting table.
- Answer the knowledge check before you read the answers.
- Stop the lab when you stop for the day. Every lab lesson ends with the command that stops or removes what it started.
Free lessons. Four lessons are free to read: this introduction, "Before you start", "What a forward deployed engineer does" and "Meet Bramfield Mutual, the customer in this course". Together they show you the job, the customer, the lab and its costs before you decide whether the course is for you.
Early access, honestly. The course is being written and released in order, lesson by lesson. Lessons are added as they are finished, each one with its own real run, its own screenshots and its own measured costs. So some lessons named here are not written yet. The lab you build on "Meet Bramfield Mutual, the customer in this course" has been built and run on a real AWS account, and every number in this lesson comes from that run or from the saved job postings. The later parts, the agent, the evaluations and production, are described here as plans, and each will be measured on the day its lesson is written.
Watch out: do not copy our output into your notes as if it were yours. Run the command yourself and compare. Times, identifiers and AI answers differ a little from run to run, and the differences are part of what you learn.
Your output from a lab command shows a different time and a different server identifier from ours. What should you do?
Show the answer
The answer: B.
Times, identifiers and AI answers differ a little from run to run, but the shape of the output should match. Only when something else differs do you turn to the lesson's troubleshooting table.
What you need
- The skills. Python, well enough to read and change a 200-line program; SQL, well enough to write a query with a join; and the terminal and Git. You do not need any AI, AWS or consulting experience: each idea is explained the first time it is needed.
- An AWS account of your own, with a payment card on it.
- A model API key, from Part 5 onwards, for the lessons that call a model. An API key is the password your code sends to a model provider, such as OpenAI or Anthropic, so the provider knows who is calling and can bill you for each call.
- An ordinary computer that runs VS Code, Python and the AWS command-line tool, on Windows, Linux or macOS. It needs no special power, because the lab runs in the cloud.
"Before you start" says exactly what this means, lists the tools and how to check each one, checks that your AWS account answers, and has a five-minute self-check in Python and SQL so you can see for yourself whether you are ready.
What a lesson's lab costs
Bramfield's systems run on one small server, and we read its price from the AWS Price List in us-east-1 on 13 November 2026. This is what make cost printed in our run:
what the lab costs per hour while it runs, us-east-1, from the AWS Price List:
the server, t2.small $0.0230
its disk, 20 GB of gp3 ($0.080 a GB-month) $0.0022
its public IPv4 address $0.0050
in all $0.0302 an hour, about $0.72 a day
stopped, you pay only for the disk: about $0.05 a day
A worked example: from the price list to a day. The three hourly prices come from the output above.
- Add the three parts: $0.0230 for the server + $0.0022 for its disk + $0.0050 for its public address = $0.0302 an hour.
- A whole day running is 24 hours: 24 x $0.0302 = $0.7248, about $0.72.
- Stopped, you pay only for the disk: 24 x $0.0022 = $0.0528, about 5 cents a day.
- Deleted, every line is gone, so the lab costs nothing.
So while the lab runs it costs $0.0302 an hour, about $0.72 for a whole day left on. Stopped, you pay only for its 20 GB disk, about $0.05 a day, and once it is deleted it costs nothing. The server also stops itself four hours after every start, in case you forget. Lessons that call a model say what their model calls cost, measured on their own run. "Before you start" sets a budget alert before anything is built, and explains why a budget only warns you rather than stopping your spending.
Watch out: a budget alert is a smoke alarm, not a sprinkler. It emails you, and it stops nothing. What stops a forgotten lab is its own four-hour timer, and what ends the cost is deleting it.
You finish for the evening and will come back tomorrow. Which choice keeps Bramfield's data and costs the least?
Show the answer
The answer: B.
A stopped server keeps its disk, and with it all of Bramfield's data, for about 5 cents a day. C is wrong because deleting removes the data too, so tomorrow you would build it again. A and D forget that a running server costs $0.0302 an hour whether you use it or not.
Your first five minutes
There is nothing to build in this lesson. Do this instead:
- Check what you know. Open "Before you start" and try its self-check before you install anything.
- Check your AWS account. If you do not have one yet, create it today. A new account can take a little time to be fully ready, and its limits can surprise you; "Before you start" shows the one command that checks them.
- Then meet the customer. "Meet Bramfield Mutual, the customer in this course" builds all of Bramfield's systems in your account with one command and walks you through them with read-only access, which is the hands-on half of everything in this lesson.
Questions people ask
- What does a forward deployed engineer course teach?
This one teaches the whole engagement with one customer, from the first meeting to the handover. You turn a vague request into a measured baseline, get into old systems safely, clean and protect personal data, build an AI agent that a person approves, prove it works with an agreed test set and a shadow run, put it into production in the customer's own AWS account, and hand it over. Everything runs on real AWS resources you build yourself.
- Is Bramfield Mutual a real insurance company?
No. Bramfield Mutual Insurance Company is fictional, and every record in its systems is synthetic, made by the course's own generator. Its Social Security numbers all use group 00, which the Social Security Administration never assigns, its VINs carry a wrong check digit, and its phone numbers sit in the 555-0100 to 555-0199 range set aside for fiction.
- How much does the AWS lab for this course cost?
In our run on 13 November 2026, Bramfield's systems cost $0.0302 an hour in us-east-1 while running, about $0.72 for a full day. Stopped, only the 20 GB disk is charged, about $0.05 a day, and a deleted lab costs nothing. The server also stops itself four hours after each start.
- Do I need AI experience to become a forward deployed engineer?
Not for this course. You need Python, SQL, the terminal and Git. The AI arrives in Part 5, and every idea, from what an agent is to how you test one, is explained when it is first needed. The 41 postings we read ask for production work and scoping at least as often as for AI agents: 37 and 32 postings, against 32 for agents.
- What skills do forward deployed engineer jobs ask for most?
In 41 postings from 18 companies, read on 13 November 2026, the most common were production deployment and reliability, in 37; working in ambiguity with ownership, in 36; AI agents, in 32; scoping and discovery, in 32; and Python, in 31. The lesson "What a forward deployed engineer does" shows the full counts.
The one-minute summary
A forward deployed engineer turns a customer's wish into a system the customer's own team runs. This course does it once, for Bramfield Mutual, a fictional insurer whose records are all made up and built so that none can be real. The wish, "We want AI for claims", becomes one problem and one number: simple claims take 20.4 days to settle. You get into old systems you did not build with read-only access, and each one has traps for careless code. In the pilot an agent drafts and an adjuster decides, and the proof is a golden set, a checked judge and a shadow run, in numbers agreed before the test. Production happens in the customer's own account under its rules, and the work ends when the claims team runs it without you. The lab behind all of this costs $0.0302 an hour while it runs.
Revision sheet
| Idea | The one line to remember | The number or example that proves it |
|---|---|---|
| The customer is fictional | Every record is made up, and none can belong to a real person. | Social Security numbers all use group 00, which is never assigned. |
| A demo is not the job | A demo shows a model can talk; the job is a system people trust daily. | 37 of 41 postings ask for production deployment. |
| One engagement, in order | Discovery, access, pilot, proof, production, handover. | Eight steps in the sequence figure, from the request to the handover. |
| Discovery | Turn the wish into one problem and one number first. | 20.4 days, averaged over 1,480 settled glass and hail claims. |
| Getting in | Read old systems carefully, read-only, through one private door. | 10 of 40 requests refused by a limit of 10 a second. |
| The pilot | The agent drafts; a person decides every claim. | The planted note asking for a $48,500 payout. |
| The proof | Answers agreed before the test, not impressions after it. | 109 outside cover, 65 fraud signals, 150 simple glass claims in the key. |
| Production | The customer's account, rules and evidence. | No shell access; data stays in US AWS regions. |
| The handover | You are done when they run it without you. | A runbook, a field report and a reusable pattern. |
| The course map | The AI arrives only in Part 5, after you can measure and read the data. | Start here, then eight parts. |
| A lesson's lab cost | Stop between sessions; delete when you go away. | $0.0302 an hour running, about 5 cents a day stopped. |
Knowledge check
Tap an answer to see straight away whether it is right, and why. You can try the whole check again at the end.
- Question 1
The head of claims says, "We want AI for claims." What should you do first?
- Question 2
Every Social Security number that Bramfield's generator writes uses group number 00. Why?
- Question 3
Try it: in our run of
make look PART=policy, 40 requests were sent to the SOAP policy service at the same moment. How many came back as a fault, and why? - Question 4
In the pilot, Bramfield's triage agent drafts a decision on a claim. What happens next?
- Question 5
The baseline says simple claims take 20.4 days to settle. Which statement about that number is true?
0 of 5 right so far, 0 of 5 answered.
Checks in this lesson: 0 of 13 answered, 0 right. The rest are in the lesson above.
Going deeper, for working engineers and staff engineers
You can skip this part and lose nothing you need for the next lesson.
Why one customer, and not many small examples. Most real difficulty in this job comes from the interaction between pieces: the date format that breaks the baseline query, the rate limit that shapes the loader, the personal data that decides where the model may run, the security rule that decides how you debug. Small separate examples hide those interactions. One customer, carried through 63 lessons, keeps them in view, and the planted mess is chosen so that each one comes back later: the 40 claims whose status changed without their update timestamp changing exist to break the incremental load in Part 3, the load that copies only what changed since last time, and the column renamed in the drops from 27 November 2026, loss_date to date_of_loss, exists to break the nightly load in Part 4.
Why the lab server is a t2.small. On 13 November 2026 our own AWS account had a limit of 1 virtual CPU for standard instances in us-east-1. The plan had pencilled in a t3.large, with 2 virtual CPUs at $0.0832 an hour, which that limit forbids. A t2.small has exactly 1 virtual CPU and 2 GB of memory, and it runs all six containers with room to spare: make check reported 807 of 1,964 MB of memory in use. A student with a higher limit can change the instance type, but nothing in the course needs it.
Why the numbers in this lesson differ slightly from some notes you may see. The baseline in this lesson, 1,480 settled simple claims, 491 open and 35.1% sent to a supervisor, is from the recorded run at 08:01 UTC on 13 November 2026, the run whose screenshots appear above. An earlier debug build the same morning printed 1,536, 497 and 35.6%, with the same 20.4 days. The generator uses a fixed seed, 1962, and fixed dates for the claims, so the same generator gives the same claims every time. The generator file was changed at 07:51 UTC, between the two builds, which is the likely reason the numbers moved; we have not traced which change did it. Every lesson quotes its own recorded run, never a number typed from notes.
Four real problems we hit building the lab. Each one is in the lesson where it belongs, because a real error that you fix teaches more than a clean run.
- Keycloak refused to import Bramfield's realm with "Illegal character ((CTRL-CHAR, code 5))", because the archive built on our computer contained hidden "._" metadata files. Building the archive with
COPYFILE_DISABLE=1fixed it. make checkfirst declared the lab ready before Keycloak answered. Setup now waits for Keycloak's own health check.- Fifteen requests in a row never tripped the policy service's limit, because each call through the Session Manager tunnel took about a second. Only requests sent at the same moment did, which is why the check sends 40 at once.
- After the lab was destroyed, the Session Manager plugin processes kept the local ports open.
make untunnelnow stops them as well.
The rules you will meet, and what is still to check. Bramfield writes policies in California and keeps personal data in claim notes, and some injury claims contain medical bills. So the course asks which rules apply to which data: a state insurance data-security law based on the model law of the NAIC, the association of state insurance regulators; California's privacy law and its exemptions for data covered by federal financial privacy law; and whether HIPAA, the federal health privacy law, applies at all to a car and home insurer. Each of these is read from its official text in the lesson that uses it, and none of it is legal advice.
Words from this lesson
The everyday words, such as claim, adjuster, engagement, baseline, synthetic data, pilot and handover, are in "Words for this lesson" near the top. These are the rest.
| Word | What it means |
|---|---|
| forward deployed engineer | a software engineer who works directly with one customer, inside its systems, until software really does the job and the customer can run it |
| discovery | finding out what really hurts, who decides what, and which number would show improvement |
| SOAP, WSDL | an older way for programs to call each other in XML; the file that describes what a SOAP service offers |
| SFTP | a secure way for systems to copy files to a server, here used for the nightly file drop |
| identity provider | the system staff sign in through; Keycloak plays Bramfield's |
| AI agent | a program that lets a language model ask for the next piece of information through tools your code controls, until it can answer |
| golden set | a set of cases whose right answers are agreed with the customer before testing |
| shadow mode | running the new system silently beside the people who do the work, and comparing its decisions with theirs |
| field report | what you learned at one customer, written so the product team can act on it |
What to keep
A forward deployed engineer turns a customer's wish into a system the customer runs. This course does that once, for Bramfield Mutual, a fictional insurer whose every record is synthetic. You will start from a request, "We want AI for claims", and a measured baseline of 20.4 days to settle a simple claim; get into old systems you did not build; run a pilot where an agent drafts and an adjuster decides; prove it with numbers the customer agreed; put it into production in the customer's own account; and hand it over.

The next lesson, "Before you start", checks your tools and your AWS account, and sets a budget alert before anything is built.
Sources
- Our own lab run of 13 November 2026, in our own AWS account in us-east-1, from the lab of the lesson "Meet Bramfield Mutual, the customer in this course": the terminal recording
runs/session-2026-11-13-a.logof that lesson, with the prompt set to show only the folder name, and its screenshotst5-policyandt6-drops. The lab reported itself built at 08:01:40 UTC. - The lab's own build notes of 13 November 2026: Terraform with 28 resources, a t2.small running Amazon Linux 2023, PostgreSQL 16.6, Keycloak 26.0.7, the 2:00 a.m. America/New_York drop timer and the four-hour automatic stop.
- The AWS Price List API, read on 13 November 2026 for us-east-1, through
make cost: t2.small $0.0230 an hour, gp3 storage $0.080 a GB-month, a public IPv4 address $0.0050 an hour. - Social Security Administration, "Social Security Number Randomization" frequently asked questions, https://www.ssa.gov/employer/randomizationfaqs.html, saved on 13 November 2026, for "will not assign group number 00 or serial number 0000".
- The skills matrix: 41 forward deployed engineer postings from 18 companies, read from the companies' public job-board APIs on 13 November 2026, with the exact matching patterns and the counts in the course's research files (
matrix.pyandmatrix-out.txt). - Colin Jarvis, OpenAI, 22 October 2026, for "the deployment gap"; the lesson "What a forward deployed engineer does" gives the full reference.
- The parts and lessons of the course: the course contents of 13 November 2026.