Platform Engineering · Lesson 221

Client Delivery for Forward Deployed Engineers

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

What you will build

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.

The story: the engineer who lives at the customer

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.

TermWhat it means
UATUser 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 OperationsThe 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 IntegrationThe final connection to the customer's real systems. The last 10 percent of the work and half of the effort.
Productized ConsultingDelivery work that turns into product. The engagement ends, but the fixes, the templates, and the feedback live on in the product.
Embedded EngineeringThe FDE working inside the customer's team, at their site, on their schedule, until the system works there.

Do this now, for one customer you know

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.

Run it as:

When it breaks, I check

One thing to remember

Four paths, one family

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.

Path 1: the clean engagement

Executive report: skipped

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.

First call0 days
Scope5 days
Data audit12 days
Legacy18 days
Air gap10 days
UAT8 days
Day 215 days

Not run yet.

Path 2: the PII surprise

Legacy and air gap: skipped

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.

First call0 days
Scope5 days
Data auditPII found
Legacynot reached
Air gapnot reached

Not run yet.

Path 3: the fee trail

Time: skipped

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.

First call$0
Scope$12k
Data audit$28k
Legacy$45k
Air gap$25k
UAT$20k
Day 2$35k
Exec report$10k
Feedback$5k

Not run yet.

Path 4: the waiting game

Working days: skipped

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.

First call2 days
Scope5 days
Data audit9 days
Legacy14 days
Air gap21 days
UAT6 days
Day 20 days

Not run yet.

Where the time goes

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.

How long to first value: move the sliders and watch the date move

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.

40 tables

How many tables the audit has to profile. Forty is a tidy customer. Two hundred is a customer with history.

3 systems

How many old systems the assistant has to read. Each one gets its own adapter, and each adapter is read-only on day one.

Fully air-gapped

0 is cloud connected. 1 is a private network. 2 is fully air-gapped: no path to the internet, everything on a drive.

2 rounds

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.

Lab: audit the schema yourself

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.

Step 0: run the audit on the messy schema

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.

Step 1: compute time-to-value by hand

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.

Check yourself

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.

Clean up

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.

Check yourself

Three questions. No score is saved anywhere. This is just you against the material.

Basic to master

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.

Basic · The first call, done well

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:

  • Discovery calls: listen first, write the requirement in the customer's words.
  • Stakeholders: the decision maker, the user, and the IT owner.
  • Success criteria in one sentence, with a number.
  • A one-page scope with what is in and what is out.

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.

Intermediate · Scope and audit

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:

  • Data audits: profile every table before promising anything built on it.
  • Schema mapping between the customer's systems and the product.
  • PII discovery and handling rules.
  • Written assumptions the customer signs off.

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.

Advanced · Legacy, air gap, and UAT

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:

  • Legacy integration through adapters and file exchanges.
  • Air-gapped and on-premises installs with no internet access.
  • User acceptance testing (UAT) rounds with written exit criteria.
  • Compliance evidence: SOC 2 controls, HIPAA safeguards for PHI, GDPR data residency.

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.

Master · Day 2, the report, and the loop

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:

  • Handover with named owners on both sides.
  • A one-page executive report: outcome, numbers, risks, next steps.
  • Product feedback loops: failed questions and missing features sent to the product team with owners.
  • Reusable engagement templates.

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.

Go deeper

Compliance from the client side

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.

The air-gapped install, in full

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.

What changes at 10x

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.

The executive report, filled in

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.

One time it broke

What broke

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.

Timeline

  • Day 12The audit flags duplicate keys in the mapping table. The team notes it and moves on.
  • Day 30The first demo. The support team asks about a customer and gets another customer's orders.
  • Day 31I check the join. The CRM customer_id is the contact, not the account. The billing customer_id is the account.
  • Day 32I rebuild the mapping table with all three meanings named. The demo runs again, and the answers match.
  • Day 35UAT starts two weeks late. The customer signs after two rounds, and the signature means more because of it.

What changed after

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.

If you remember nothing else

Design exercise

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.

Clarifying questions to ask

  • Who signs the business associate agreement, and before what date?
  • Where does the protected health information live, and what must never leave the building?
  • How many runbooks, how many tables, how many legacy systems?
  • Who runs UAT, and are they clinicians or administrators?
  • What does first value mean to the hospital: one ward, one runbook set, or the whole hospital?

Worked approach

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.

Next in this series · Lesson 222
Portfolio & Interviews

A portfolio is not a list of projects. It is one project a stranger can run, check, and believe in ten minutes. This lesson builds that project. It is a small triage assistant.

Go to Lesson 222 →

Or browse the full course from the Lessons index.