The FDE Portfolio: Build Projects That Prove Deployment Velocity and Land the Offer

Why Standard Portfolios Fail the FDE Bar

A typical software engineering portfolio showcases a clean, self-contained app—a to-do list built with React, a microservice with 100% test coverage, a polished mobile app. These projects demonstrate code quality and framework knowledge, but they completely miss what makes a Forward Deployed Engineer valuable.

Forward Deployed Engineer open roles aren't about writing code in isolation. They're about walking into a customer's environment—often a messy, legacy, air-gapped, or heavily regulated system—and shipping a solution that works today. The hiring manager at Palantir, OpenAI, Anthropic, or Google Cloud isn't looking for clean architecture diagrams. They're looking for evidence you can handle ambiguity, reverse-engineer undocumented APIs, debug production failures without access, and translate a vague customer pain point into a working feature before the week ends.

Your portfolio needs to scream one thing: deployment velocity. It must prove you can go from a customer conversation to a live, integrated feature faster than anyone expects. The projects below aren't about showing off your Python skills—they're about demonstrating the operational instincts that justify $200K–$500K+ total compensation packages.

The Three Pillars of an FDE Portfolio

Every high-signal FDE portfolio contains three distinct types of evidence. You don't need ten projects—two or three that hit these pillars carry more weight than a dozen generic CRUD apps.

Pillar 1: The 'Zero-to-One' Integration Spike

This is the centerpiece. Build a project that connects at least three previously unconnected systems to solve a real problem. The key word is unconnected—don't build a standard API mashup. Instead, integrate tools that were never designed to talk to each other.

What to build: A Gmail AI triage agent that reads incoming emails, classifies urgency using a local or cloud LLM, drafts contextual replies, and logs everything to a Notion database. This hits Gmail (OAuth, Google Workspace APIs), an LLM (Groq for speed, demonstrating latency awareness), and Notion (a knowledge tool, not a traditional database). The full build guide is here: Build a Gmail AI Triage Agent That Drafts Replies Using Gemini and Groq.

Another strong option: a Notion knowledge assistant that answers questions from your workspace using Supabase and LlamaIndex. This demonstrates retrieval-augmented generation in a customer-like environment—unstructured data, permission boundaries, and the need for accurate, sourced answers. Walk through it here: Build a Notion Knowledge Assistant That Answers Questions from Your Workspace.

What to document:

• The exact moment you hit an undocumented API behavior and how you worked around it (screenshots of Postman/curl debugging)
• A timestamped log showing total elapsed time from empty directory to working integration
• A 60-second screen recording of the full flow working end-to-end

Pillar 2: The 'Chaos Monkey' Debugging Artifact

FDEs spend a shocking amount of time debugging systems they didn't build, often without access to the source code, logs, or the original engineers. Your portfolio needs to show this muscle.

Pick a real-world failure scenario and document your debugging process step-by-step. The best format is a written post-mortem with timestamps, hypotheses, and the eventual root cause.

Example scenario: An on-call incident summarizer that ingests logs via Groq and Playwright, then fails silently on certain log formats. Document how you isolated the failure—did you binary-search the input space? Did you instrument the pipeline with structured logging? Did you reproduce the issue in a minimal environment? Build reference: Build an On-Call Incident Summarizer from Logs with Groq and Playwright.

What to document:

• The initial symptom ("summary returned empty for 12% of incidents")
• Your hypothesis tree: what you ruled out and why
• The tooling you used (mitmproxy for intercepting API calls, tcpdump for network issues, Python's logging module with custom handlers)
• The root cause and the fix, with code diffs
• A reflection on what monitoring or alerting would have caught this earlier

This artifact proves you don't panic when things break in prod—you systematically isolate and fix.

Pillar 3: The 'Business Value' Demo Loop

Technical skill gets you the interview. Business communication gets you the offer. FDEs sit at the intersection of engineering and customer success—you must be able to demo a feature in a way that makes a VP of Operations lean forward.

Record a 3-minute demo of one of your projects where you:

1. State the customer pain point in their language ("Your sales team spends 4 hours a week personalizing outreach emails")
2. Show the before state (manual, error-prone, slow)
3. Show the after state (automated, fast, measurable)
4. Quantify the impact ("This reduces per-email personalization time from 8 minutes to 30 seconds")

A cold outreach email personalizer that reads from a CSV of prospects and generates tailored emails using Groq is perfect for this. It's a common enterprise pain point, and the ROI math is simple. Build it here: Build a Cold Outreach Email Personalizer from a CSV of Prospects.

What to document:

• The recording itself (hosted on Loom or as an unlisted YouTube video)
• A one-page "executive summary" PDF with the ROI calculation
• A link to the working code

Architecture of a High-Signal Project

Here's what the integration flow looks like for the Gmail AI triage agent—notice it's not a single app, but a pipeline across systems that were never designed to interoperate.

The point isn't the code's elegance—it's that you navigated OAuth scopes, handled rate limits, parsed messy HTML emails, and chained two LLM calls with a decision gate. That's a Tuesday for an FDE.

From Portfolio to Interview: Framing Your Work

When you present these projects in an FDE interview loop, frame every decision through the lens of customer impact and velocity. The FDE Interview Loop Decoded covers the full process, but here's the portfolio-specific framing:

For the integration spike: "I noticed the customer's team was manually triaging 200+ vendor emails daily. I built a proof-of-concept in 3 hours that connected Gmail, Groq, and Notion—reducing triage time by 80%. The hardest part was handling Gmail's OAuth refresh token flow in a stateless n8n environment. Here's how I solved it."

For the debugging artifact: "The summarizer failed on 12% of log formats because the upstream log shipper was silently truncating lines over 4096 characters. I found this by binary-searching the input space and adding structured logging at each pipeline stage. The fix was a 4-line change to buffer and reassemble truncated lines."

For the business demo: "Here's a 3-minute walkthrough showing how this personalizer turns a CSV of 500 prospects into tailored outreach emails in under 2 minutes. At an average sales rep salary of $85K, this saves roughly $8,500 per rep per year in manual personalization time."

Every answer ties technical work to business outcomes. That's the FDE superpower.

---

FAQ: FDE Roles, Salaries, and Career Path

What is the role of forward deployed engineer in OpenAI? At OpenAI, FDEs embed with enterprise customers to integrate models like GPT-4o and o-series into production environments. The work spans prompt engineering, API integration, custom fine-tuning pipelines, and navigating strict security and compliance requirements. It's a customer-facing engineering role—you write code, debug customer issues, and shape the product roadmap based on what you see in the field.

How much do FDEs get paid? Forward Deployed Engineer compensation typically ranges from $180K to $500K+ total compensation, depending on seniority and company. Base salaries at top firms (Palantir, OpenAI, Anthropic) often sit between $150K–$250K, with significant equity or profit-sharing on top. Enterprise-facing roles that directly drive revenue command a premium over pure R&D engineering.

How much does a forward deployed engineer make in OpenAI? Based on public data and levels.fyi reports, OpenAI FDE roles range from approximately $250K to $500K+ total compensation, with a heavy equity component. Senior and staff-level FDEs who lead strategic customer deployments can push toward the upper end. The role is classified as revenue-critical, which drives higher comp bands.

What engineer makes $500,000 a year? Engineers reaching $500K+ annually typically fall into a few categories: Staff/Principal engineers at FAANG companies (with stock appreciation), AI/ML research engineers at top labs (OpenAI, Anthropic, DeepMind), and Forward Deployed or Solutions Engineers at high-growth enterprise SaaS companies where compensation is tied to customer revenue impact. FDE roles uniquely combine engineering depth with direct revenue attribution, which accelerates comp growth.

What's the difference between an FDE and a Solutions Engineer? Solutions Engineers typically configure existing products and write lightweight scripts. FDEs write production code, often building net-new features or integrations that don't exist yet. The FDE role requires deeper engineering skills and operates with more autonomy—you're not just demonstrating the product, you're extending it inside the customer's environment.

Do I need a security clearance for FDE roles? Some FDE roles at defense-oriented companies (Palantir, Anduril) require or prefer a security clearance, but the majority of commercial FDE roles at companies like OpenAI, Anthropic, Stripe, and Google Cloud do not. The core requirement is the ability to navigate complex enterprise environments, not a specific clearance level.