A forward deployed engineer does not ship a model. A forward deployed engineer ships a working system inside a customer's real world, on the customer's network, against the customer's data, on a date the customer signed. The demo worked in the office. The engagement is where it has to work in the customer's building. This lesson walks one engagement from the first call to Day 2: the requirements, the scope, the data audit, the legacy systems, the air-gapped install, the testing, the handover, the report, and the feedback loop. The model is one hop. The delivery is the other eight.
Difficulty: Advanced · Know this first: Lesson 215, Lesson 196, Lesson 154, Lesson 138
By the end of this lesson you will have run a data audit on a messy customer schema, written a one-page scope, computed time-to-value for an engagement, and read a one-page executive report. First, a data-audit script that profiles every table, flags PII hiding in a free-text column, and warns when one column name means different things in different tables. Second, a scope one-pager with in, out, and later. Third, the time-to-value math, by hand and in the simulator. You will also know the FDE glossary, the compliance conversation from the client side, and what an air-gapped install actually demands.
What you need: Python 3 for the audit script and the time-to-value math. Nothing in this lesson runs against a live cloud or a live customer. The schema is a sample file on your machine, and its outputs are shown exactly as they ran.
A forward deployed engineer is an engineer who works at the customer's site, on the customer's problem, until the system works there. The name comes from the field. Forward deployed means you go forward, to the customer, and you stay until it works. The job is half engineering and half delivery: you gather requirements in the customer's words, you scope the work, you audit the data, you integrate the legacy systems, you install behind the customer's firewall, you run user testing with the customer's people, you hand the system over, you report to the executives, and you carry what you learned back to the product team.
The customer in this lesson wants an assistant that answers questions from their runbook library. Their support team answers the same 40 questions every day. The goal, in their words: our support team should answer from the runbooks, not from memory. That sentence is the requirement. Everything in this lesson hangs off it.
| Term | What it means |
|---|---|
| UAT | User acceptance testing. The customer tests the system with their own questions on their own data, and signs when it is good enough to use. |
| Day 2 Operations | The work after go-live: updates, runbook changes, access, the first real page. Day 2 starts the day the system goes live, not the day the contract ends. |
| Last-Mile Integration | The final connection to the customer's real systems. The last 10 percent of the work and half of the effort. |
| Productized Consulting | Delivery work that turns into product. The engagement ends, but the fixes, the templates, and the feedback live on in the product. |
| Embedded Engineering | The FDE working inside the customer's team, at their site, on their schedule, until the system works there. |
Write the one sentence that says what success looks like, in the customer's words, not yours. Then write the name of the person who signs when it is done. If you cannot write both, you do not have a requirement yet. You have a conversation.
The diagram above follows one engagement from the first call to Day 2. These four paths are the same idea drawn four ways. One engagement, clean. One engagement, stopped by a PII surprise. One fee trail, hop by hop. One count of the waiting. Run each path. One run takes 7.2 seconds across the path, so you can watch each hop light up in turn.
The return rule: the green dot only starts moving after the orange dot reaches the data hop. A return with no request is a lie. The diagram never draws one. The failure replay at the end of Run all four shows the other side of the rule. Remove the air-gap approval, and the orange dot stops at the air-gapped deploy and never comes back.
One engagement walks from the first call to a live system. First call, scope, data audit, legacy integration, air-gapped deploy, UAT, Day 2 operations. The report and the feedback loop happen after go-live. Every hop lands on its planned day.
Not run yet.
Same engagement, one bad column. The audit finds customer email addresses in a column named notes_public. The work stops at the audit. Nothing downstream can start until the customer reclassifies the data and signs the handling form.
Not run yet.
The same engagement, priced hop by hop. Each hop shows its share of a $180,000 fixed fee. The legacy work is the biggest line, because the old systems are the work. The model itself is not a line. It is inside every hop.
Not run yet.
The same engagement, counted in waiting, not working. Each hop shows the days spent waiting on the customer: an approval, an access grant, a sign-off. 57 days of waiting against 75 days of work. The waiting is the hidden half of every engagement.
Not run yet.
Every hop charges rent in working days. The bar below is a worked example for one engagement, not a measurement from a live project, but the shape is honest. One millisecond stands for one working day, so the 75 ms total is a 75-day engagement. The data and the old systems take most of it. The model takes almost none of it. Move a simulator slider and watch the audit, legacy, air-gap, and UAT hops change with it. Switch the scenario and watch the messy data or the blocked air gap change the total instead.
The budget bar above shows three fixed stories. This simulator lets you write your own. It answers the question the executive asks first: when does the customer see the first value. You set how many tables the schema has, how many legacy systems to integrate, how air-gapped the install is, and how many UAT rounds the customer needs. Move a slider and watch the audit, legacy, air-gap, and UAT hops in the budget bar change, and the time-to-value with them. The numbers are a teaching example, built from the formulas below, not live measurements. The shape is the lesson: the data and the old systems decide the date, not the model.
How many tables the audit has to profile. Forty is a tidy customer. Two hundred is a customer with history.
How many old systems the assistant has to read. Each one gets its own adapter, and each adapter is read-only on day one.
0 is cloud connected. 1 is a private network. 2 is fully air-gapped: no path to the internet, everything on a drive.
How many rounds of user acceptance testing the customer runs. Two is the plan. A third round means the first two found something real.
Try this: (1) At the defaults, 40 tables, 3 systems, fully air-gapped, 2 UAT rounds, the audit costs 12 days, the legacy work 18, the air-gap deploy 10, and UAT 8. Time-to-value is 53 days and the engagement totals 75 days. (2) Drop to a small clean customer: 10 tables, 1 system, cloud connected, 1 UAT round. The audit costs 3 days, the legacy work 6, the deploy 4, and UAT 4. Time-to-value is 22 days and the engagement totals 44 days. (3) Push to a big messy customer: 120 tables, 6 systems, fully air-gapped, 4 UAT rounds. The audit costs 36 days, the legacy work 36, the deploy 10, and UAT 16. Time-to-value is 103 days and the engagement totals 125 days. From the defaults, the messy customer costs 50 more days to first value, and 48 of those days are the audit and the legacy work.
Formulas, in plain terms. Audit days = tables times 0.3, rounded up to whole days. Legacy days = systems times 6. Air-gap days = 4 plus level times 3. UAT days = rounds times 4. Time-to-value = scope 5 days plus audit plus legacy plus air-gap plus UAT. Total engagement days = time-to-value plus 22 days: Day 2 operations 15, the executive report 4, the feedback loop 3. The budget bar counts one millisecond for each working day, so the total in days is the total in milliseconds. The numbers are a teaching example. Your customer will differ. The shape will not.
Do this now, on your own machine. You will run a data audit on a messy customer schema, read the two findings that matter, break the schema on purpose, and compute time-to-value by hand. The Python parts run on this machine and their outputs are shown exactly as they ran. The schema is a sample file. Your customer's schema will differ. The findings will not.
Save this file as audit_schema.py. It profiles every table, flags PII hiding in a free-text column, and warns when one column name means different things in different tables. Save the schema as messy_schema.json. It has three tables: customers, orders, and a legacy billing table.
"""Data audit for a customer schema. Standard library only.
Run it against messy_schema.json, the schema dump from the story.
It profiles every table, flags PII hiding in a free-text column, and
warns when one column name means different things in different tables.
"""
import json
import re
import sys
EMAIL_RE = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
SSN_RE = re.compile(r"\b\d{3}-\d{2}-\d{4}\b")
PII_NAMES = {
"email": "an email address",
"phone": "a phone number",
"ssn": "a social security number",
"full_name": "a name",
"name": "a name",
}
def load(path):
with open(path, encoding="utf-8") as f:
return json.load(f)
def audit(path):
schema = load(path)
flags = 0
warnings = 0
seen = {}
for table in schema["tables"]:
rows = table["rows"]
cols = table["columns"]
print(f"Table {table['name']}: {rows} rows, {len(cols)} columns")
dupes = table.get("key_duplicates", 0)
if dupes == 0:
print(f" key {table['key']}: unique (0 duplicates)")
else:
print(f" key {table['key']}: {dupes} duplicates")
for col in cols:
name = col["name"]
seen.setdefault(name, []).append(
(table["name"], col["type"], col["sample"][0]))
if name in PII_NAMES:
print(f" PII? {name} looks like {PII_NAMES[name]}")
samples = [str(v) for v in col["sample"] if v is not None]
if any(SSN_RE.search(v) for v in samples):
if name not in PII_NAMES:
print(f" PII? {name} holds social security numbers in free text: "
f"FLAG, reclassify before load")
flags += 1
if any(EMAIL_RE.search(v) for v in samples):
if name not in PII_NAMES:
print(f" PII? {name} holds email addresses in free text: "
f"FLAG, reclassify before load")
flags += 1
nulls = col["nulls"]
if nulls:
pct = nulls / rows * 100
print(f" nulls: {name} {nulls} ({pct:.1f}%)")
for name, uses in seen.items():
if len(uses) > 1:
types = {u[1] for u in uses}
formats = {str(u[2]) for u in uses}
print(f"Shared column {name} in {len(uses)} tables:")
for tname, ctype, sample in uses:
print(f" {tname}.{name} is {ctype}, sample {sample}")
if len(types) > 1 or len(formats) > 1:
print(" WARNING: same name, different type and format. "
"Do not join before the mapping table is written.")
warnings += 1
flag_word = "flag" if flags == 1 else "flags"
warn_word = "warning" if warnings == 1 else "warnings"
print(f"Audit verdict: {flags} PII {flag_word}, {warnings} join {warn_word}, "
f"0 duplicate keys. Do not load until both are cleared.")
if __name__ == "__main__":
audit(sys.argv[1])
{
"tables": [
{
"columns": [
{
"name": "customer_id",
"nulls": 0,
"sample": [
101,
102,
103
],
"type": "int"
},
{
"name": "full_name",
"nulls": 12,
"sample": [
"Asha Rao",
"Ben Carter",
"Meera Nair"
],
"type": "text"
},
{
"name": "email",
"nulls": 301,
"sample": [
"asha@example.com",
"ben@example.com",
null
],
"type": "text"
},
{
"name": "notes_public",
"nulls": 0,
"sample": [
"prefers email contact: asha@example.com",
"call after 6pm",
"vip, see ben@example.com"
],
"type": "text"
},
{
"name": "created_at",
"nulls": 0,
"sample": [
"2024-01-05",
"2024-02-11",
"2024-03-02"
],
"type": "timestamp"
}
],
"key": "customer_id",
"key_duplicates": 0,
"name": "customers",
"rows": 48210
},
{
"columns": [
{
"name": "order_id",
"nulls": 0,
"sample": [
9001,
9002,
9003
],
"type": "int"
},
{
"name": "customer_id",
"nulls": 0,
"sample": [
101,
102,
101
],
"type": "int"
},
{
"name": "total",
"nulls": 0,
"sample": [
49.99,
129.5,
12.0
],
"type": "numeric"
},
{
"name": "status",
"nulls": 874,
"sample": [
"shipped",
"pending",
null
],
"type": "text"
}
],
"key": "order_id",
"key_duplicates": 0,
"name": "orders",
"rows": 129884
},
{
"columns": [
{
"name": "customer_id",
"nulls": 0,
"sample": [
"C-101",
"C-102",
"C-103"
],
"type": "text"
},
{
"name": "balance_due",
"nulls": 0,
"sample": [
0.0,
45.2,
0.0
],
"type": "numeric"
},
{
"name": "last_invoice",
"nulls": 1190,
"sample": [
"2026-09-01",
"2026-10-15",
null
],
"type": "date"
}
],
"key": "customer_id",
"key_duplicates": 0,
"name": "legacy_billing",
"rows": 48210
}
]
}
Run it:
python3 audit_schema.py messy_schema.json
Expected output, exactly as it ran on this machine:
Table customers: 48210 rows, 5 columns key customer_id: unique (0 duplicates) PII? full_name looks like a name nulls: full_name 12 (0.0%) PII? email looks like an email address nulls: email 301 (0.6%) PII? notes_public holds email addresses in free text: FLAG, reclassify before load Table orders: 129884 rows, 4 columns key order_id: unique (0 duplicates) nulls: status 874 (0.7%) Table legacy_billing: 48210 rows, 3 columns key customer_id: unique (0 duplicates) nulls: last_invoice 1190 (2.5%) Shared column customer_id in 3 tables: customers.customer_id is int, sample 101 orders.customer_id is int, sample 101 legacy_billing.customer_id is text, sample C-101 WARNING: same name, different type and format. Do not join before the mapping table is written. Audit verdict: 1 PII flag, 1 join warning, 0 duplicate keys. Do not load until both are cleared.
Read the two findings. The first is the PII flag. A column named notes_public holds customer email addresses in free text. The name says public. The content says private. The audit catches it before any data loads, and the handling decision goes in writing before the load. The second is the join warning. The column customer_id appears in three tables, and the legacy billing table stores it as text with a C- prefix while the other two store it as a number. A join written without the mapping table matches nothing, or worse, matches the wrong rows. The incident section of this lesson is what happens when the team writes the join anyway.
Now break it on purpose. Add a column named ssn_text to the customers table, with sample values like 123-45-6789, and run the audit again. The verdict moves from 1 PII flag to 2. The script flags social security numbers in free text the same way it flags emails. Change it back when you are done.
Run the same arithmetic the simulator uses, on your own machine. Change the numbers to your own engagement and read the total.
python3 -c "tables=40; systems=3; level=2; rounds=2; audit=tables*0.3; legacy=systems*6; airgap=4+level*3; uat=rounds*4; ttv=5+audit+legacy+airgap+uat; print('audit %.0f days' % audit); print('legacy %.0f days' % legacy); print('air-gap %.0f days' % airgap); print('uat %.0f days' % uat); print('time-to-value %.0f days' % ttv); print('total %.0f days' % (ttv+22))"
Expected output, exactly as it ran on this machine:
audit 12 days legacy 18 days air-gap 10 days uat 8 days time-to-value 53 days total 75 days
That total is the same 75 days the simulator shows at its defaults, and the same 53 days to first value. Two different paths, one number. When two paths agree, the number is worth trusting.
Change the air-gap level from 2 to 0 in the simulator and watch the deploy hop fall from 10 days to 4. Then ask what the customer gave up for those 6 days: the air gap. The trade is the lesson. Now change the tables from 40 to 120 and watch the audit hop triple. The data is the engagement, and the simulator just proved it with your own hand on the slider.
Nothing to clean. The audit script and the schema live on your machine, and you can run them again on the next engagement. The next schema you audit will be real, and the findings will be yours.
Three questions. No score is saved anywhere. This is just you against the material.
Client delivery is not one skill. It is four levels of the same job, and every team I have worked with sits on one of them. The levels are not about how many terms you can name. They are about whether the customer gets a working system on a date you can defend. Read them in order. Each level fixes the failure that hurt the most at the level below it.
At the basic level, you run the first call and you write the scope. You listen, you write the requirement in the customer's words, and you name the decision maker and the one sentence of success. The failure that ends this level is the second call. One good call feels like an engagement. It is not. It is a start.
Types:
Uses: The start of every engagement, where misunderstandings are cheapest to fix.
Scale and failure: With one customer, a good relationship covers gaps; with ten, unwritten scope becomes ten different products. A standard discovery template keeps every engagement comparable.
Trade-off: A tight scope protects the timeline and may say no to something the customer cares about; a loose scope pleases everyone in week one and nobody in week six.
Do this: write the one-page scope for the support assistant in the story. In scope, out of scope, later. One owner, one date for first value. If you cannot name the owner, you do not have a scope yet.
Try it: Basic
I had one good first call with the customer. What do I have?
Now do it: Write the one-page scope for the support assistant in the story. In scope, out of scope, later. One owner, one date for first value. If you cannot name the owner, you do not have a scope yet.
At the intermediate level, the audit is a script and the scope is a page you can defend. You run audit_schema.py against the customer's schema, you profile every table, and you write the mapping table for the legacy systems. A column that means two things gets caught here, not in the demo.
Types:
Uses: Finding the problems in the customer's data before they appear in a demo.
Scale and failure: Real customer data has columns that mean two things, duplicate records, and gaps; a scripted audit finds them in an hour and a manual read misses them. PII found late can stop an engagement for weeks of legal review.
Trade-off: An audit delays the first demo by days and prevents the demo that fails in front of the customer's leadership.
Do this: run step 0 of the lab. Read the PII flag and the join warning. Then add one column to the sample schema and run it again. Watch the report change.
Try it: Intermediate
I run audit_schema.py against the customer's schema. What does it catch here, not in the demo?
Now do it: Run step 0 of the lab. Read the PII flag and the join warning. Then add one column to the sample schema and run it again. Watch the report change.
At the advanced level, you own the hard half: the legacy adapters, the air-gapped install, the UAT rounds, and the compliance conversation. You can explain SOC 2, HIPAA, and GDPR from the client side: what evidence the auditor asks for, how PHI is handled, where the data lives. You know the frameworks live in Lesson 154, and this lesson is the engagement side of them.
Types:
Uses: Enterprise and regulated customers, where the hard part is fitting into their environment, not building the feature.
Scale and failure: Every customer environment is a little different; adapters and install scripts built for one should be productised so the next engagement starts further ahead. UAT without written exit criteria never ends.
Trade-off: Custom adapters win the deal and become maintenance; pushing changes back into the product costs time now and saves it on every later engagement.
Do this: write the air-gap checklist for your own install. What goes on the drive, what the checksums are, what you prove with the cable unplugged. If a line on the list needs the internet, the list is wrong.
Try it: Advanced
I am planning the air-gapped install. What proves the checklist is right?
Now do it: Write the air-gap checklist for your own install. What goes on the drive, what the checksums are, what you prove with the cable unplugged. If a line on the list needs the internet, the list is wrong.
At the master level, the engagement ends cleanly and the product gets better. The handover names an owner on each side. The executive report fits on one page. The failed-question list goes back to the product team with an owner. The next engagement starts from the templates the last one left behind. That is productized consulting.
Types:
Uses: Turning one-off consulting into a repeatable motion that also improves the product.
Scale and failure: Forward-deployed teams scale when each engagement leaves templates, adapters, and product fixes behind; without that, cost grows linearly with customers.
Trade-off: Time spent on reports and feedback looks like overhead in a busy week, and it is what makes the next engagement faster and the product better.
Do this: write the executive report for your own engagement, using the template in Go deeper. One number that moved, one date, one next step. If it does not fit on one page, it is not a report yet.
Try it: Master
The engagement is ending. What makes the handover clean?
Now do it: Write the executive report for your own engagement, using the template in Go deeper. One number that moved, one date, one next step. If it does not fit on one page, it is not a report yet.
SOC 2 is the auditor asking for evidence that access is controlled and logged, and the FDE is the person who collects it from the engagement: who had access, what they touched, when. HIPAA changes the handling when the data holds protected health information. A business associate agreement is signed before any data moves, and PHI never lands in a log or a demo. GDPR is about data residency: the data stays in the region the customer names, and the customer can ask for a person's data to be deleted. The frameworks themselves are taught in Lesson 154. This lesson is the engagement side: the conversation, the evidence, and the signature. The PII guardrail that catches the problem at runtime is taught in Lesson 196. The audit in this lesson catches it before the system ever loads.
What goes on the drive: the model weights, the container images, the runbooks, the install script, the checksums file. What happens on site: verify the checksums first, install from the drive, prove the system answers with the cable unplugged, then hand the drive back. What never happens: a download, a license check that phones home, a model update over the internet. The update path is a new drive, with new checksums. The serving engine the install runs is taught in Lesson 181, and the model it serves comes from the lifecycle in Lesson 215. The delivery in this lesson is what puts the two together inside the customer's walls.
At 10 customers, the engagement stops being a craft and becomes a playbook. The audit script, the scope one-pager, the air-gap checklist, and the executive report template are the same every time, and the differences are the customer's data and the customer's network. At 10x the customers, the feedback loop is the product roadmap. The 20 failed questions from ten customers tell the product team what to build next, and the FDE is the person who brings the list.
This is the one-page report for the story engagement, exactly as it went out on day 75. Copy the shape, change the numbers to your own engagement.
# Executive report: one page Customer: the support team, runbook assistant engagement Report date: day 75, engagement close ## What the money bought - Cost: $180,000 fixed fee - First value: day 53 - What moved: the support team answers 40 questions a day from the runbook library ## What is still manual - The billing-system adapter is read-only. Writes still go through the old screen. ## What is next - Add the second runbook set, starting day 90. Owner: the product team.
Three systems, one column name, three meanings. The billing system used customer_id for the account. The CRM used it for the contact. The spreadsheet used it for the site. The join matched accounts to the wrong contacts, and the first demo showed the support team answering questions about the wrong customers. The demo questions were answered confidently, from the wrong rows.
Two things. First, the audit now includes a same-name-different-meaning check. A column that appears in two tables with different types or formats is a warning before any join is written. Second, no join ships without a row-count reconciliation. The mapping table is the most valuable file in the engagement, and it is written before the demo, not after it.
Design the delivery plan. A hospital wants an AI assistant that answers staff questions from its clinical runbooks. HIPAA applies. The network is air-gapped. The hospital wants the first value in 6 weeks. Design the engagement: scope, audit, integration, deploy, UAT, Day 2, and the executive report.
Scope it first. In scope: one ward, one runbook set, staff questions only, no patient data in the answers. Out of scope: patient records, a second ward, a second language. Later: the whole hospital. The audit comes before the install, and PHI classification comes first in the audit. A column that holds patient data is flagged before any load, and the handling decision is in writing.
Then the install. The air-gap install is a drive with checksums, proven with the cable unplugged. The model update path is a new drive, and the hospital plans for that in the Day 2 runbook. UAT is run by clinicians with real questions, two rounds, and every failure gets a named fix and a retest date. Day 2 names an owner on the hospital side and an owner on your side, and the runbook has restart, roll back, and add a document. The executive report is one page: first value on day 42, one number that moved, one next step with a date.
Trade-offs to name. Speed versus compliance is not a trade. HIPAA does not bend for a date, and the business associate agreement is signed before data moves, not after. Scope versus date is the real trade: one ward in 6 weeks, or the whole hospital in 12. UAT versus date is not a trade either: clinicians test it, or nobody signs. The air gap versus updates is a trade worth naming: every model update is a new drive, and the hospital plans for that in the Day 2 runbook.
Saved in this browser, so the Lessons index can show your progress across the course.