The Field Deployed Engineer's Handbook

The Role

Chapter 1: The New Field Engineer

1. The Production Gap That Created a Profession
2. What a Forward Deployed Engineer Actually Does
3. From Palantir Curiosity to Industry Standard
4. Why AI Makes Field Engineering Essential
5. FDE vs Everything Else
6. Real Engineering or Fancy Consulting?
7. The Pod and the FDE
8. Do You Need an FDE?
9. The Harness Engineering Connection
10. The FDE Mindset
11. Field Exercise
12. Key Takeaways

Chapter 2: The Honest Career

1. Why Engineers Are Interested Now
2. Will This Keep Me Technical?
3. A Realistic Week
4. Career Paths
5. Compensation
6. The Interview
7. Positioning Your Application
8. Burnout, Travel, and Red Flags
9. Negotiating the Offer
10. Field Exercise
11. Key Takeaways

Chapter 3: The Capability Model

1. The T-Shaped Field Engineer
2. The Five Capability Families
3. The Maturity Model
4. The Minimum Viable Technical Stack
5. The Learning Path
6. Field Exercise
7. Key Takeaways

The Method

Chapter 4: Discovery in the Real World

1. The Gravel Track
2. The First Week Determines Everything
3. Three Lenses, Not Three Phases
4. Preparing for the First Week
5. The Five-Day Discovery Protocol
6. Stakeholder Interviews
7. The Discovery Output
8. Field Exercise
9. Key Takeaways

Chapter 5: Discovering the Work

1. Two Processes
2. The Prototype Is the Instrument
3. The Process Is Already Written Down, in the ERP
4. Choosing the Unit of Work
5. Watching People Work
6. The Process Specification
7. Exception Archaeology
8. Deciding What the Agent Does
9. Measuring the Baseline Before You Change It
10. Validating the Specification
11. Field Exercise
12. Key Takeaways

Chapter 6: Discovering What People Know

1. Four Seconds
2. Four Kinds of Knowledge
3. Why Interviews Fail
4. Elicitation
5. Writing Knowledge Down
6. The Data Half
7. Bias, and What You Are Encoding
8. What Not to Capture
9. Knowing Whether It Worked
10. Field Exercise
11. Key Takeaways

Chapter 7: Discovering the Tools of the Job

1. Eleven Applications
2. Inventory From the Desk Outward
3. The Tool Inventory
4. The Interface Ladder
5. From Tools to Actions
6. Who Is the Agent?
7. Observability and Somewhere to Fail
8. Feasibility, and the Honest Report
9. Field Exercise
10. Key Takeaways

Chapter 8: From Ambiguity to Executable Plans

1. The Translation Problem
2. Writing Outcome Statements
3. From Outcome to Plan
4. Choosing the Right Delivery Vehicle
5. Managing Scope Without Losing Momentum
6. Demo-Driven Development Without Demo Theatre
7. Writing Plans That Both Sides Trust
8. Field Exercise
9. Key Takeaways

Production

Chapter 9: AI Patterns for Field Engineers

1. Start by Not Using AI
2. The Building Blocks
3. Agent Patterns in Practice
4. Context Engineering
5. RAG: When It Helps and When It Distracts
6. Tool Use and MCP Servers
7. Keeping Architecture Simple Enough to Ship
8. Field Exercise
9. Key Takeaways

Chapter 10: Data, Integration, and Customer Systems

1. The Job Is Integration
2. Integration Patterns
3. Structured, Semi-Structured, and Unstructured Data
4. Data Access, Identity, and Least Privilege
5. Source-of-Truth Problems
6. MCP: The Integration Standard
7. The Smallest Useful Vertical Slice
8. The Last Mile
9. Field Exercise
10. Key Takeaways

Chapter 11: Evaluation and Harness Engineering

1. The Model Is Not the Product
2. The Six Harness Layers
3. The Ratchet Principle
4. Eval-Driven Development: The OpenAI FDE Method
5. The Counter-Intuitive Testing Result
6. Evaluation Infrastructure
7. Harness Maturity Levels
8. Building Harnesses That Survive the Engagement
9. Field Exercise
10. Key Takeaways

Chapter 12: Production, Security, and Governance

1. Why Demos Lie
2. Production Readiness: Six Dimensions
3. The AI Threat Model
4. Harness Security: Engineering, Not Hope
5. CI/CD for AI Systems
6. Incident Response for AI
7. The EU AI Act: What FDEs Must Know
8. Performance, Cost, and Token Accounting
9. Field Exercise: The Production Readiness Review
10. Key Takeaways

The Human Side

Chapter 13: Working with Customers

1. The Order-Taker Trap
2. The Trust Spectrum
3. Explaining AI Limitations Without Undermining Confidence
4. Handling Sceptics and Champions
5. Negotiating Trade-Offs
6. Making Invisible Progress Visible
7. Field Survival
8. The “Permanent Crutch” Anti-Pattern
9. Field Exercise: The Weekly Field Update
10. Key Takeaways

Chapter 14: Adoption, Handover, and Product Feedback

1. The FDE’s Real Deliverable
2. The Autonomy Ladder
3. Training by Doing, Not by Telling
4. The Agentic Pod
5. Handover Milestones
6. Documentation That Survives
7. The N-to-1-to-N Lifecycle
8. Separating Customer-Specific from Reusable
9. The Field Report
10. The Harness as Ultimate Handover Artefact
11. Field Exercise: The Handover Plan
12. Key Takeaways

Chapter 15: Leading and Scaling the Practice

1. The View from Above
2. The Consulting Trap
3. The FDE Lead Role
4. Staffing Model
5. Quality Standards for Field Deliverables
6. Career Paths
7. Portfolio Visibility
8. Building Reusable Harness Components
9. A Complete End-to-End Scenario: Project Atlas
10. Hiring in a Candidate-Driven Market
11. Field Exercise: The Hiring Rubric
12. Key Takeaways

Field-Ready Python

Chapter 16: Modern Python Idioms

1. Learning Objectives
2. Prerequisites
3. What transfers, and what will surprise you
4. The data model: the protocols behind the syntax
5. Idioms that read as senior
6. Summary
7. Review Questions
8. Exercises
9. Further Reading

Chapter 17: Typing and Data Modelling

1. Learning Objectives
2. Prerequisites
3. Typing: the checking the compiler used to do for you
4. Modelling data: a dataclass in the core, pydantic at the ports
5. Summary
6. Review Questions
7. Exercises
8. Further Reading

Chapter 18: Async and Concurrency for Agents

1. Learning Objectives
2. Prerequisites
3. The async model, and when it earns its place
4. Running tool calls in parallel
5. Deadlines, cancellation, and protecting critical work
6. Streaming model output
7. Backpressure and concurrency limits
8. Summary
9. Review Questions
10. Exercises
11. Further Reading

Chapter 19: The Modern Python Toolchain

1. Learning Objectives
2. Prerequisites
3. Environments and dependencies with uv
4. Linting and formatting with ruff
5. The shape of a project: pyproject.toml
6. The API you leave behind
7. Configuration that fails fast with pydantic-settings
8. Command-line interfaces with typer
9. Summary
10. Review Questions
11. Exercises
12. Further Reading

Chapter 20: Testing and Reliability

1. Learning Objectives
2. Prerequisites
3. pytest and async tests
4. Testing non-determinism: mock at the narrowest boundary
5. Property-based testing with Hypothesis
6. Reliability: timeouts, retries, and circuit breakers
7. Handling errors by recoverability
8. Summary
9. Review Questions
10. Exercises
11. Further Reading

Chapter 21: FastAPI Services and Integration

1. Learning Objectives
2. Prerequisites
3. Typed endpoints with pydantic
4. Streaming agent output over SSE
5. Auth, background tasks, and structured logging
6. Packaging the service as a starter kit
7. Summary
8. Review Questions
9. Exercises
10. Further Reading

Framework-Agnostic Agent Engineering

Chapter 22: The Agent Loop from Scratch

1. Learning Objectives
2. Prerequisites
3. The four primitives
4. Writing the loop with no framework
5. The same loop across providers
6. Hardening the bare loop
7. Recognising the loop inside the SDKs
8. Summary
9. Review Questions
10. Exercises
11. Further Reading

Chapter 23: Tools, Function Calling, and Structured Output

1. Learning Objectives
2. Prerequisites
3. A tool is a typed schema
4. One pydantic model, three envelopes
5. Strict mode: stop parsing and retrying
6. Structured output: shaping the final response
7. Summary
8. Review Questions
9. Exercises
10. Further Reading

Chapter 24: Context Engineering, RAG, and Retrieval

1. Learning Objectives
2. Prerequisites
3. What enters the context, and why less is more
4. Grounding the agent in data: RAG
5. Keeping the window from overflowing: compaction and editing
6. Remembering across sessions: memory
7. Summary
8. Review Questions
9. Exercises
10. Further Reading

Chapter 25: Multi-Agent Orchestration

1. Learning Objectives
2. Prerequisites
3. Workflows versus agents, and starting simple
4. The five essential primitives
5. The patterns in the production runtimes
6. Essential versus incidental: the durable model
7. Summary
8. Review Questions
9. Exercises
10. Further Reading

Chapter 26: MCP: Interop Across Ecosystems

1. Learning Objectives
2. Prerequisites
3. The architecture: hosts, clients, and servers
4. The three primitives, by who controls them
5. Authoring a server
6. Consuming across clients and SDKs
7. Summary
8. Review Questions
9. Exercises
10. Further Reading

Chapter 27: Evaluation, Observability, and Guardrails

1. Learning Objectives
2. Prerequisites
3. Evaluation: knowing it works before you ship
4. Observability: seeing what it does
5. Guardrails: keeping it safe
6. Summary
7. Review Questions
8. Exercises
9. Further Reading

Field-Ready TypeScript

Chapter 28: TypeScript for Typed-Language Engineers

1. Learning Objectives
2. Prerequisites
3. The type system, mapped
4. zod: pydantic for TypeScript
5. The async and module toolchain
6. Summary
7. Review Questions
8. Exercises
9. Further Reading

Chapter 29: Node and the AI SDKs

1. Learning Objectives
2. Prerequisites
3. Two SDKs, two jobs
4. Streaming, mapped from Chapter 18
5. Typed tools with zod
6. Summary
7. Review Questions
8. Exercises
9. Further Reading

Chapter 30: Next.js Agent Demos

1. Learning Objectives
2. Prerequisites
3. The App Router: server and client
4. A streaming agent UI over your FastAPI agent
5. Deploying the demo
6. Summary
7. Review Questions
8. Exercises
9. Further Reading

Conclusion

1. The harness is the job, and the gap is why the role exists
2. The primitive outlives the framework
3. Types are where you put the pressure
4. Non-determinism is an engineering problem, not an excuse
5. What you leave behind
6. Where to go next