The FDE Portfolio: What to Build to Get Hired (It's Not a To-Do App)

The standard software engineering portfolio is a trap for aspiring Forward Deployed Engineers. A beautiful React front-end with a Node.js back-end and a MongoDB instance—the classic "to-do app" or "Twitter clone"—signals that you can follow a tutorial. It doesn't signal that you can walk into a Fortune 500 logistics company, diagnose why their legacy AS/400 system can't talk to a modern AI model, and ship a working prototype by Friday.

A Forward Deployed Engineer portfolio isn't judged by code cleanliness alone. It's judged by signal density: does this candidate understand the messy intersection of business logic, customer pain, and technical constraints? The projects need to scream, "I ship in the chaos."

The FDE Portfolio Mismatch: Why Your To-Do App is a Red Flag

Hiring managers for FDE roles—typically at companies like Palantir, Scale AI, or high-growth AI startups—are scanning for a very specific anti-pattern: genericism. A generic portfolio tells us you optimized for learning a framework, not solving a problem.

In the FDE world, the problem is never technical in isolation. It’s always a tangled mess of:

• Bad data: CSV files with 50,000 rows where the date format changes halfway through.
• Strict constraints: The client’s security team banned external API calls, but you need to use an LLM.
• Vague requirements: “Make our dispatchers 10% faster,” with no existing metrics.

Your portfolio must replicate these constraints artificially. If your project can be built by following a YouTube tutorial in an afternoon, it’s invisible noise. We need to see the decomposition muscle.

The 3-Project Rule: Signal Density Over Volume

You don't need 10 projects. You need a maximum of three high-signal artifacts. Quality is measured in “decision density”—how many non-trivial trade-offs you made per 100 lines of code. Here is the exact blueprint for the three projects that map directly to the weekly reality of an FDE.

Project 1: The Enterprise Data Ingestion & Unblocking Engine

The Scenario: A client has a critical business workflow that relies on unstructured data locked in PDFs, scans, or legacy exports. They need it structured for an AI system, but the data is dirty and the volume is high.

What to Build: An invoice or receipt extractor that turns PDFs into structured JSON, but with a twist. Don't just call the OpenAI API on a clean PDF. Build a pipeline that handles the "unhappy path."

Your implementation must handle:

• Malformed PDFs: Scanned images where OCR is required.
• Rate Limiting & Cost Logic: Implement a cascading strategy. Try a fast, free model first (e.g., Gemini Flash), and only fall back to a more expensive model if the confidence score is low.
• Human-in-the-Loop: A minimal interface (can be CLI) that flags low-confidence extractions for manual review, outputting a "correction log" that could theoretically be used for fine-tuning.

High-Signal Details:

• Use a free-tier model to keep it running indefinitely.
• Store the extracted JSON in a local SQLite database, not just printing to console.
• Include a Dockerfile because enterprise environments often run air-gapped.

Internal Link: This maps directly to the patterns in our Invoice and Receipt Extractor guide, but you must add the cascading model logic and the human review loop.

Project 2: The High-Stakes Workflow Decomposition

The Scenario: A client wants to automate a complex research task, but the output directly impacts a customer-facing report. Accuracy is non-negotiable.

What to Build: A multi-agent research assistant that plans, searches, and writes a brief. But don't just chain prompts. Implement structural guarantees.

Your implementation must include:

• The Plan Phase: An agent that takes a vague topic ("market trends for EV batteries") and outputs a structured research plan (JSON) with specific search queries.
• The Execution Phase: A sub-agent that executes the searches (using Tavily, SerpAPI, or a free alternative) and saves raw results.
• The Synthesis Phase: A writer agent that takes the raw results and the original plan, producing a report. Crucially, it must cite its sources inline.
• The "FDE Guardrail": Before the final output is shown, a critic agent checks if every claim in the report has a matching source in the raw data. If not, it loops back.

Code Pattern (Skeleton):

class ResearchOrchestrator:
    def __init__(self, max_retries=3):
        self.planner = PlannerAgent()
        self.searcher = SearchAgent()
        self.writer = WriterAgent()
        self.critic = CriticAgent()
        self.max_retries = max_retries

    def execute(self, topic: str) -> str:
        plan = self.planner.create_plan(topic)
        raw_data = self.searcher.gather(plan.queries)
        
        for attempt in range(self.max_retries):
            draft = self.writer.synthesize(plan, raw_data)
            validation = self.critic.validate_citations(draft, raw_data)
            if validation.is_valid:
                return draft
            raw_data = self.searcher.gather(validation.missing_sources)
        
        raise Exception("Failed to produce validated report")

Internal Link: The architecture here aligns with the orchestration logic in our Multi-Agent Research Assistant walkthrough. The key difference for your portfolio is the critic loop—that’s the FDE signature.

Project 3: The AI-Enabled Operational Hack

The Scenario: Not every FDE project is a massive pipeline. Sometimes it’s a tactical tool that saves a specific team 10 hours a week.

What to Build: A voice assistant for your terminal. This sounds like a toy, but it’s a powerful signal of privacy-aware, local-first engineering—a massive concern in enterprise AI.

Your implementation must run entirely locally:

• STT (Speech-to-Text): Local Whisper model.
• LLM: Ollama running a local model (Llama 3 or similar).
• TTS (Text-to-Speech): Piper TTS.

Why this wins: It shows you understand that FDE work often happens behind strict firewalls where OpenAI is blocked. It proves you can stitch together open-source tools into a cohesive product that solves a real (if small) problem. Document the latency trade-offs you made (e.g., choosing a smaller Whisper model for speed over accuracy).

Internal Link: You can bootstrap this using the component pipeline in Build a Voice Assistant for Your Terminal, but you must integrate it into a single, easy-to-launch script with a requirements.txt.

Architecture Patterns That Scream 'FDE'

When an FDE hiring manager scans your repo, they are pattern-matching for specific architectural diagrams. They don't want to see a standard MVC app. They want to see graphs and pipelines.

This diagram—a cascading router with a confidence gate and a human-in-the-loop queue—should be the hero image of your Project 1 Readme. It immediately communicates that you think about cost, reliability, and edge cases.

For Project 2, the diagram should show a cyclic graph, not a linear pipeline. The critic agent creates a loop back to the search agent. This signals that you understand agentic systems aren't just scripts; they are state machines.

Presenting the Artifact: The Readme as a Technical Narrative

An FDE’s primary output is often a technical narrative—a design doc, a scoping statement, or a post-mortem. Your portfolio’s Readme is your chance to prove you can write one. Do not use a generic template.

Structure your Readme like a mini engagement summary:

1. Customer Problem (Context): “A logistics coordinator spends 3 hours daily manually extracting shipment IDs from scanned PDFs. Errors cause misrouted pallets.”
2. Constraints: “Solution must run on a CPU-only machine due to client VPN restrictions. Budget for external APIs is capped at $5/day.”
3. Trade-offs: “We chose EasyOCR over Tesseract for better accuracy on crumpled paper scans, accepting a 200ms latency penalty.”
4. Failure Modes: “If the PDF is password-protected, the system gracefully logs the failure and moves to the next file rather than halting the batch.”

This format demonstrates you can bridge the gap between a business problem and a technical solution—the literal definition of the role. For more on how these artifacts are evaluated, see our breakdown of The FDE Interview Loop.

FAQ: The FDE Portfolio

Should I host my FDE portfolio online, or is a GitHub repo enough? A well-documented GitHub repo is far more powerful than a flashy personal website. FDEs value substance. The evaluator will clone your repo and try to run it. Make sure the setup is a single command (docker compose up or pip install -r requirements.txt && python main.py). If they can’t run it in 5 minutes, it’s a negative signal.

How do I show enterprise scale in a personal project? You can’t fake scale, but you can simulate its challenges. Use generators instead of loading entire CSVs into memory. Use asyncio for concurrent processing. Add a --sample flag that processes a random 1% of data for quick demos. These small touches show you’ve deployed to production before.

Is it a red flag to use AI tools like Copilot to build the portfolio? No, it’s expected. FDEs are force multipliers. However, you must be able to explain every line of code in an interview. If you use an AI to scaffold a complex regex, add a comment linking to the regex101 page where you tested it. This shows you are using AI to accelerate, not to think for you.

What salary can an FDE expect, and does a portfolio impact that? Forward Deployed Engineer salaries at top AI firms range from $150,000 to $250,000+ base, with significant equity upside. A strong portfolio doesn't just get you the job; it gets you leverage in negotiation. If your project directly mirrors a problem the hiring company is currently facing, you’ve moved from “candidate” to “solution.” For a gritty, real-world look at the day-to-day that commands this salary, read What a Forward Deployed Engineer Actually Does in a Week.

Should I include a data analysis project? Only if it’s operationalized. Don't include a Jupyter Notebook where you plot some graphs. Instead, build a SQL analyst agent that answers questions over a Postgres database. This shows you can give non-technical stakeholders a natural language interface to their data. The pattern for this is detailed in our SQL Analyst Agent guide.