OKFDE FIELD NOTES #003｜How an FDE Engagement Actually Runs

KEY TAKEAWAY
Enterprise AI engagements rarely fail because the model cannot extract clauses from a PDF. They fail because nobody mapped who actually holds signature authority on a verbal discount, what happens when the ERP writeback times out mid-flight, or why an operator will quietly abandon a shiny new web portal if it requires an extra login. Shipping an agentic workflow requires a disciplined seven-stage loop: Discover, Scope, Build, Deploy, Adopt, Measure, and Productize.

COLD OPEN

The stalled purchase order and the five-box slide

Monday’s kickoff meeting has the unmistakable energy of a Silicon Valley keynote. The VP of Operations, Alex, is walking the room through a slide deck with immaculate gradient arrows.

In the center of the projection screen sit five clean boxes:

The AI Lead is about to launch into a discussion on context windows and parameter counts when Leo, the Forward Deployed Engineer, points at the fourth box.

“Could we pull up the last purchase order from yesterday that missed its approval SLA?” Leo asks.

The room pauses. Alex pulls up the legacy ERP.

Sitting in the queue is Order #40912, frozen in Pending Approval. The customer has a custom annual volume discount agreement, but the ERP’s built-in routing engine couldn’t match the rule. The reviewer didn’t dare click approve, so the order sits in limbo.

“Who usually untangles these?” Leo asks.

“Talk to Clara.”

Clara, the senior order operations specialist who has kept the back office from catching fire since 2017, walks over. She glances at the order ID, alt-tabs out of the ERP, opens a scanned PDF from last year’s master agreement, and pulls up a local, 17-tab Excel workbook she maintains on her desktop.

The annual discount agreement only covers legacy SKUs. Order #40912 mixes in three newly launched product lines. The account executive verbally promised the client the legacy discount would apply to the new items, but there is zero written record of that promise inside the ERP.

Leo points back to the five-box architecture diagram glowing on the wall. “Which of those five boxes checks verbal discount promises on new SKUs?”

Clara looks at the gradient arrows and smiles politely. “None of them. We resolve that in a private Slack DM with the regional sales director.”

The architecture diagram is ready for production. The company’s actual workflow hasn’t even been documented yet.

01 / DISCOVER

Follow the Operator Before Writing the Prompt

For the next forty-eight hours, Leo does not open an IDE. He pulls a borrowed folding chair up beside Clara’s desk.

From inside an engineering sandbox, enterprise business logic looks like a clean decision tree. Sitting beside a frontline operator watching her alt-tab across six windows reveals how much friction the human nervous system is quietly absorbing.

To clear a single purchase order, Clara’s right hand never leaves the mouse:

• She checks line-item SKU quantities in the legacy ERP.

• She verifies the customer’s credit tier in Salesforce.

• She cross-references promotional tier overrides against her local Excel workbook.

• She pulls the signed contract addendum from a permission-locked SharePoint folder.

• And then comes the real bottleneck: waiting four hours for a regional sales rep to reply in Slack confirming that a new SKU qualifies for last year’s pricing.

Worse still is the authority boundary. Even after the sales rep confirms the discount in Slack, and even when Clara knows the order aligns with historical precedent, Clara does not hold the delegation of authority to approve an off-sheet discount. Any variance above 15% requires formal sign-off from the Regional VP.

If an engineering team only listened to the kickoff presentation, they would wire “Clara’s validation passes” directly to the ERP auto-approval trigger. In production, that deployment would silently bypass executive financial controls on day one.

Automating a workflow requires mapping both where the data lives in the database and where the liability lives in the org chart.

In the OKFDE methodology, this phase is Discovery. A foundation model can extract pricing clauses from a 200-page PDF in seconds, but the FDE must establish strict data provenance: which contract page holds authority, which spreadsheet cell overrides the catalog, and whose Slack handle actually carries legal sign-off.

By Tuesday evening, Every extracted rule has a named human owner signing off on it. Sales leadership defines the SKU eligibility boundary; Finance confirms approval thresholds; IT marks which endpoints allow read queries and which write operations are strictly off-limits. The five-box slide now has twenty-seven exception branches attached to it. For the first time, everyone in the room understands why Order #40912 actually stalled.

02 / SCOPE

Draw a Hard Perimeter on Day Three

Once a customer sees their hidden operational mess mapped onto a whiteboard, their appetite inevitably expands. Now that Clara’s 17-tab spreadsheet is out in the open, leadership wants the AI agent to solve all seventeen exception types, parse informal Slack promises, and automate cross-regional escalations by next Friday.

This is where an FDE earns their keep by saying no.

The documentation for special promotional overrides is fragmented, and the delegation-of-authority rules for traveling executives are still disputed between Sales and Finance. Forcing ambiguous business rules into an automated pipeline means engineers end up guessing corporate policy in Python.

Leo draws a thick red line across the whiteboard. The initial two-week pilot will cover Standard Orders in a single sales region.

A “Standard Order” is defined by deterministic, verifiable criteria: active customer credit status, unit pricing strictly within the published authorization matrix, and complete contract attachments. If an order references an off-sheet verbal agreement, or if any single verification check returns ambiguous provenance, the system immediately aborts auto-processing and routes the order to the human review queue.

Order #40912—the new-SKU discount exception from the kickoff meeting—is explicitly excluded from auto-approval. Leo places it into the evaluation suite’s Mandatory Human Escalation bucket. The system isn’t supposed to bypass the Regional VP’s signature; its job is to package the evidence so the VP can approve it in ten seconds instead of two days.

This is the Minimum Viable Workflow (MVW): narrow enough to ship into production in two weeks, yet complete enough to carry real operational traffic from ingest to ERP writeback.

Before a single line of application code is written, Leo gets Alex to sign off on two operational guardrails: who owns clearing the exception queue at 4:00 P.M. every day, and how the team falls back to manual processing if the service degrades. Clara’s 17-tab Excel workbook stays right on her desktop. Nobody needs to force an early retirement on a load-bearing spreadsheet in week one.

03 / BUILD

The Model Is Smart, Until Customer IDs Don’t Match

In a local Jupyter notebook, the model looks brilliant. Feed it a clean PDF contract, and it extracts payment terms and liability caps with surgical precision.

Then Leo connects the pipeline to the customer’s staging environment, and enterprise plumbing immediately fights back.

The legacy ERP outputs Customer IDs as 10-digit integers. The CRM stores accounts using alphanumeric regional codes. Worse, a single enterprise buyer often operates four subsidiary entities across different states. If you let an LLM fuzzy-match customer records by company name, it will cheerfully merge the credit limits of two legally distinct subsidiaries.

Leo sits down with the database administrator and builds a deterministic entity-resolution mapping table. The rule is unforgiving: if an entity match carries any ambiguity, the order halts and logs the exact missing key. In enterprise AI, admitting “record not found” is an engineering virtue; hallucinating a join across subsidiary ledgers is a career-limiting event.

Architectural boundaries are similarly partitioned:

• Deterministic code handles arithmetic, credit-limit comparisons, and price-sheet threshold checks.

• The foundation model is restricted to what it actually does well: extracting unstructured discount clauses from scanned PDFs and returning the exact page number and verbatim text span.

• The policy engine validates the extracted schema and provenance before deciding whether an order can advance. Even if the model outputs the text “This order meets all criteria and should be approved,” that string has zero execution authority over the ERP write endpoint.

While inspecting the staging database schema, Leo spots a column named customer_status_final_v2. It looks like the exact boolean flag the workflow needs. He walks over to the sysadmin’s cubicle to ask if it is reliable.

The sysadmin squints at the screen and rubs his temples. “Oh, don’t touch that. A contractor created that column two years ago before he left. The cron job that syncs it probably died in 2024.”

# Schema Reality Check: Staging DB
# Column: customer_status_final_v2 (BOOLEAN)
# Documentation: “ Source of truth for active credit standing “
# Operational Reality: Sync cron job silently failed 19 months ago.
# Rule: Never trust a database column just because the word ‘final’ is in the name.

Leo’s evaluation suite shifts accordingly. Instead of testing fifty pristine happy-path orders, the team injects corrupted payloads: expired contract attachments, colliding subsidiary IDs, revoked SharePoint read tokens, and stale database flags. A build only passes when every single poisoned order safely lands in the human escalation queue without throwing an unhandled exception.

04 / DEPLOY

The Writeback Timed Out—Did the Order Approve or Not?

On the afternoon of the production dress rehearsal, data ingestion and contract extraction run without a hitch. Then, on the final step, the legacy ERP’s SOAP approval endpoint throws a network timeout.

Red text fills the terminal. A junior engineer on the call immediately suggests the standard web-dev reflex: “Let’s wrap the POST request in an exponential backoff retry loop.”

Leo reaches across the desk and physically puts his hand over the keyboard.

In a distributed enterprise environment, a write timeout is the most dangerous state in computing. If the approval packet actually reached the ERP and mutated the database state, and only the HTTP 200 response got dropped by an aging internal firewall, a blind retry will execute a double approval—or worse, trigger duplicate downstream warehouse fulfillment.

You never retry an enterprise write operation until you have deterministically verified the system state.

Leo and the team wire an idempotency key and version hash into every outbound approval payload. When a timeout occurs, the gateway automatically fires a read-only state probe against the ERP. If the order status remains ambiguous, the workflow locks the record into a Pending Verification state, halts automated writebacks, and pages the human operator.

Every transaction writes an immutable audit trail: which contract SHA-256 hash was read, which policy version evaluated the thresholds, and which service account or human operator authorized the final state transition.

Even then, the team does not flip the switch to full autonomy on day one. The system launches in Shadow Mode. For the first several hundred live orders, the agent ingests data and logs its recommended decision silently in the background while Clara processes orders manually as usual. Only after the shadow logs prove zero false-positive approvals does the team enable automated writebacks for standard regional orders—with a physical, one-click emergency kill switch taped right next to the operations lead’s monitor.

05 / ADOPT

The Dashboard Is Green, and Clara Still Opened Excel

The system goes live on Tuesday morning. Backend telemetry is spotless. Latency is under 400 milliseconds. Error rates are zero.

At 2:00 P.M., Leo walks over to Clara’s desk to see the triumph of modern AI firsthand. Clara’s monitor is displaying the legacy ERP order list. The sleek, custom React web application the engineering team spent three weeks building is minimized in the background.

Clara slides her mouse toward Leo. “Sit down and process one order using your new portal,” she says.

Leo sits down and tries it:

1. The new web app times out its session every thirty minutes, demanding a fresh SSO login and a two-factor SMS code.

2. To check an order, Clara has to copy the 10-digit order ID from the ERP, alt-tab to the AI portal, paste the ID, wait four seconds, read a terse badge that says Criteria Met, and then alt-tab back to the ERP to manually type the approval note.

3. Because the portal only displays Criteria Met without showing the underlying contract clause, Clara doesn’t trust it enough to sign her name to the audit log—so she opens the PDF anyway.

Frontline operators rarely reject new software out of ideological stubbornness. They reject it because the engineering team accidentally added four extra clicks to their day.

That afternoon, Leo’s team scraps the standalone web portal.

Instead of forcing Clara to visit a new destination, they embed a lightweight browser extension directly into the legacy ERP screen she already stares at eight hours a day. When Clara opens an order in the ERP, the extension silently reads the order ID from the DOM, fetches the verification payload in the background, and renders the recommendation right below the native approval button.

Hovering over the recommendation pops up a highlighted snippet of the exact contract page and pricing table. If Clara disagrees with the agent’s suggestion, she can override it inline by selecting a reason code from a dropdown—which automatically logs a labeled failure sample for the engineering team.

For orders requiring executive escalation, a single click dispatches a structured approval card directly to the Regional VP’s Slack with the contract snippet attached. To prevent escalated exceptions from getting buried under incoming volume, the team adds a dedicated countdown timer and visual highlight to the exception queue.

You cannot measure enterprise adoption by counting backend API pings or mandatory logins. True adoption happens the moment the operator stops alt-tabbing back to her shadow workaround.

06 / MEASURE

Now We Can Calculate How Much Faster It Actually Is

At the two-week retrospective, Alex asks the only question that justifies the budget: “So, how much faster is our order cycle?”

Only now does Leo project the benchmark table onto the screen. The figures below reflect an illustrative pilot methodology tracking 200 consecutive Standard Orders in the target sales region across two comparable two-week operating windows:

Two numbers in this table require engineering honesty.

First, the turnaround metric measures total wall-clock time from order ingest to final ERP status change—including the hours an order spends sitting in a human queue waiting for someone to look at it.

Second, 38% human intervention is an intentionally unvarnished number. It means that out of 200 orders nominally classified as “standard,” 76 still hit a rule boundary, missing attachment, or data mismatch that required at least one human review or override. Claiming that the department’s total workload dropped by 62% would be fiction; what dropped was the mechanical drudgery of verifying the 124 clean orders.

Leo breaks the 11.5-hour speedup into its real components: how much came from sub-second machine extraction versus how much came from eliminating queue-wait time between Sales and Operations. The evaluation report also preserves the long-tail outliers—the gnarly orders that sat unresolved for seventy-two hours—rather than quietly trimming them from the denominator as “statistical anomalies.”

Alongside speed, the team tracks token inference cost per order and API latency against the value of operator hours saved. Order #40912 from the kickoff meeting is still excluded from the automated denominator—but its escalation path is now a documented, measurable benchmark for Phase Two.

07 / PRODUCTIZE

Don’t Leave Bespoke Scrap Metal Behind

As the pilot winds down, Leo sits down with the core product engineering team back at headquarters.

If the goal were merely to close a consulting contract, Leo could leave the client-specific scripts running on a VM and walk away. Do that ten times, however, and an AI company turns into a low-margin maintenance agency drowning in custom cron jobs.

The team performs surgical decoupling:

• Customer-specific artifacts stay in tenant configuration: The client’s regional discount tiers, subsidiary ID mapping tables, and delegation-of-authority thresholds are isolated inside a declarative configuration file stored strictly within the customer’s private environment.

• Battle-tested plumbing graduates to the platform: The versioned idempotent writeback gateway, the timeout state-probe harness, the inline ERP browser overlay, and the reason-coded human override card have zero dependency on this specific manufacturer’s business logic. They are refactored into standard, unit-tested platform primitives.

• Field failure modes become synthetic evals: Without removing a single byte of customer PII or contract text from the client’s network, Leo codifies the structural failure patterns—colliding subsidiary IDs, dead boolean flags, SOAP 504 timeouts—into synthetic stress tests inside OKFDE’s core evaluation suite.

The OKFDE Delivery Loop is never a rigid, one-way waterfall. When Clara has to alt-tab one too many times on day five, the team drops straight back from Adopt to Build. When exception queues pile up during week two, the team revisits Scope. The loop is an engineering diagnostic to ensure no stage is skipped before declaring victory.

08 / RETURN TO REALITY

One month later, Leo stops by the client’s floor for a routine check-in.

Clara is sitting at her desk, moving through the morning queue inside her familiar ERP screen. Standard orders arrive pre-verified with inline contract snippets ready for a single keystroke. Orders missing attachments or carrying off-sheet pricing sit neatly in a highlighted exception queue, tagged with the exact reason they were halted.

Order #40912—the new-SKU discount headache from kickoff Monday—cleared weeks ago. The account executive attached the promotional scope note directly through the escalation card, the Regional VP approved it from his phone at the airport, and the immutable audit log linked both signatures to the ERP record.

Clara’s 17-tab Excel workbook is still sitting on her desktop. She just hasn’t needed to copy-paste a standard order number into it since the second week of the pilot.

A new hire rolls his chair over to Clara’s desk with a question about a disputed invoice. Clara clicks the inline evidence badge on her screen, pops up page 14 of the master agreement, and walks him through the clause without opening a single folder.

Leo sits on the folding chair in the corner, drinks his water, and says nothing.

When an enterprise AI deployment actually works, the room no longer needs an engineer in it to explain why.

NEXT / FIELD NOTES · 004

All unit tests are green, inference latency is under 200ms, and the executive sign-off dinner was a triumph—yet six weeks later, frontline operators have quietly gone back to their spreadsheets. A field post-mortem on swivel-chair friction, asymmetric liability, and why employees silently reject enterprise AI.

SOURCES & EVIDENCE

This Field Note uses a composite order-approval engagement to illustrate recurring production delivery patterns. Characters, dialogue, and pilot metrics are illustrative syntheses rather than disclosures of a specific client engagement:

[1] Anthropic — Building Effective Agents (2024). Informs our architectural separation between probabilistic LLM extraction, deterministic workflow orchestration, and human-in-the-loop verification.

[2] Microsoft Azure Architecture Center — Retry Pattern & Idempotency. Grounds our distributed systems discussion on writeback timeouts, state probing, and preventing duplicate state mutations.

[3] OKFDE Research — FDE Workbench & Production Delivery Standard (2026). Provides the seven-stage OKFDE Delivery Loop (Discover, Scope, Build, Deploy, Adopt, Measure, Productize) and Minimum Viable Workflow scoping criteria.

ABOUT OKFDE

OKFDE is a research, engineering, and talent platform focused on Forward Deployed Engineering for enterprise AI. We turn lessons from real-world deployments into practical methods for delivering, operating, and improving AI systems.

Train. Build. Deploy.

For enterprise deployment inquiries, workshops, or field research:

leo@okfde.net