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

You are not applying for a job building software. You are applying for a job solving problems that happen to involve software, usually inside a Fortune 500 company’s broken data pipeline at 2 AM. A to-do app demonstrates you can follow a tutorial. It doesn’t demonstrate you can stare at a customer’s undocumented SOAP API, a folder of 10,000 scanned PDFs, and a VP who needs a structured dashboard by Friday.

Hiring managers for Forward Deployed Engineering roles—at Palantir, Scale AI, Shield AI, and a growing number of AI-native startups—are filtering for a specific signal: technical empathy paired with ruthless decomposition. Your portfolio needs to scream “I ship into chaos,” not “I completed a bootcamp.”

This article breaks down the three project archetypes that actually move the needle, the technical decisions that matter, and how to frame them in a narrative that gets you to the onsite. We’ll focus on concrete, buildable artifacts that use the free tiers of modern AI tools.

The FDE Portfolio Problem

A standard software engineering portfolio optimizes for code quality, test coverage, and system design elegance. An FDE portfolio optimizes for input entropy. The ugliest, most impressive FDE project is one that takes the messiest real-world input and produces a ruthlessly clean output.

What hiring managers are actually asking:

• Can this person ingest a format they’ve never seen before?
• Can they handle failure states that aren’t just try/catch blocks?
• Can they explain a complex technical tradeoff to a non-technical stakeholder in the README?

A hiring manager at a top AI defense contractor recently noted: “I don’t care about your React state management. I care that you once wrote a script to diff two versions of a 900-page PDF regulation and output a structured change log. That’s the job.”

Archetype 1: The Data Extraction & Liberation Artifact

This is the single highest-signal project you can build. The goal is to take unstructured documents—PDFs, images, scans—and turn them into pristine structured data that a downstream system can consume. This directly mirrors the “day one” task of many FDEs: liberating customer data from legacy systems.

What to build: An invoice and receipt extractor that processes a folder of messy PDFs (scanned, native text, mixed) and outputs a single clean JSON array.

Why this works: It forces you to handle PDF parsing libraries (PyMuPDF, pdfplumber), OCR fallbacks (Tesseract), and LLM-based extraction (Gemini Flash free tier). The real skill is building a router that decides which extraction path to use based on the document’s characteristics.

Key technical decisions that impress:

• Chunking strategy: Don’t just dump a 50-page PDF into a prompt. Write a heuristic that splits on whitespace boundaries and respects token limits, then aggregates results.
• Schema design: Define a strict Pydantic model for an invoice (vendor, date, line items, total). Validate the LLM’s output against it and implement a retry loop with the validation error fed back into the prompt.
• Cost observability: Log token usage per document. This is a pure FDE instinct—knowing what your solution costs to run.

For a step-by-step build guide on exactly this project, including the prompt engineering for structured extraction, see our deep dive: Build an Invoice and Receipt Extractor That Turns PDFs into Structured JSON Using Gemini Flash Free Tier.

The narrative hook: Frame this as “I helped a hypothetical logistics customer who had 5 years of paper invoices in a filing cabinet. Here’s the pipeline I built in an afternoon.”

Archetype 2: The Autonomous Research & Synthesis Agent

FDEs are force multipliers. You aren’t just writing code; you’re building small, focused agents that do the work of a junior analyst. This archetype demonstrates you understand tool-use, planning, and the delegation of reasoning.

What to build: A multi-agent research assistant that takes a natural language query, plans a research strategy, executes web searches, and writes a structured brief with citations.

Why this works: It shows you can orchestrate multiple LLM calls with distinct system prompts. One agent plans, another searches, a third synthesizes. This is a miniature version of the “decomposition” round in an FDE interview.

Technical decisions that matter:

• Separation of concerns: Don’t use a single monolithic prompt. Define a Planner agent that outputs a JSON list of search queries, a Searcher agent that calls Tavily or SerpAPI, and a Writer agent that receives the raw search results and produces the final brief.
• Context window management: Show you’re thinking about token limits. Implement a summarization step for each fetched page before passing it to the writer.
• Deterministic tool calls: Use Groq’s fast inference for the planner and router steps to keep latency low, reserving a larger model for the final synthesis.

We have a complete tutorial that walks through building this exact system using Groq’s free tier for the agent brains and Tavily for the search layer: Build a Multi-Agent Research Assistant That Plans, Searches, and Writes a Brief with Groq and Tavily.

The narrative hook: “A partner at a consulting firm needed a daily brief on a competitor’s product moves. I built an agent that replaced 3 hours of manual research each morning.”

Archetype 3: The Bare-Metal Voice/Interface Glue

FDEs often work in constrained environments—air-gapped networks, terminals, or edge devices. A project that runs entirely locally, without cloud dependencies, signals you can ship into environments where pip install isn’t an option.

What to build: A voice assistant that runs entirely in your terminal, using local Whisper for speech-to-text, Ollama for the LLM, and Piper TTS for text-to-speech.

Why this works: It demonstrates you understand the stack from the metal up. You’re managing audio device I/O, subprocess pipelines, and model inference without a single API key. This is the project that gets brought up in the interview.

Key decisions:

• Pipeline architecture: Use Unix pipes or Python’s subprocess to connect the components. Avoid frameworks that obscure the flow of data.
• Latency optimization: Show you’ve thought about user experience. Implement streaming from Ollama so the user hears the response begin before it’s fully generated.
• Error handling for hardware: What happens if the microphone isn’t found? What if the Whisper model isn’t downloaded? Handle these gracefully with clear terminal output.

For the full build guide, including model selection and latency tuning: Build a Voice Assistant for Your Terminal Using Local Whisper, Ollama, and Piper TTS.

The narrative hook: “I built a voice-controlled assistant for a hypothetical manufacturing floor where cloud connectivity is prohibited. It runs on a Raspberry Pi and helps technicians query maintenance logs hands-free.”

The FDE Portfolio Narrative Framework

A list of projects is not a portfolio. An FDE portfolio is a persuasive document. Each project should follow a specific structure in its README that mirrors an FDE customer engagement:

1. The Customer Problem (1 paragraph): Who is the user? What was the broken, manual, or impossible workflow? Write this as if you’re explaining it to the VP who controls the budget.
2. The Technical Approach (2-3 paragraphs with a diagram): What did you build? Include a simple architecture diagram (you can generate one using the React Flow JSON format we used above). Explain the 2-3 critical design decisions you made and why. Mention alternatives you rejected.
3. The Ship Log (bullet points): FDEs ship fast and iterate. Include a short log of what you built on Day 1, Day 2, and Day 3. This demonstrates your velocity and decomposition skills. Example: “Day 1: Got a single native PDF parsing correctly into JSON. Day 2: Added OCR fallback for scanned docs and built the classifier. Day 3: Wrote the retry logic for schema validation errors.”
4. Cost & Performance (table): A simple table showing the cost to run the pipeline per document or per query, and the latency. This is the FDE’s instinct to measure everything.

This framework transforms a GitHub repo from “another side project” into “evidence this person can do the job on day one.”

FAQ: FDE Portfolios

How to build a portfolio to get hired?

Build three projects that demonstrate data extraction, autonomous orchestration, and local/constrained deployment. Frame each project as a solution to a realistic, messy customer problem. Use the narrative framework above in every README. The goal is to show you can ingest chaos and output structure.

What are the three types of career portfolios?

In the FDE context, they aren’t “frontend, backend, fullstack.” They are: (1) The Liberation Artifact (unstructured to structured data), (2) The Synthesis Agent (orchestrating LLMs and tools to replace a human workflow), and (3) The Bare-Metal Glue (running inference entirely locally in a constrained environment). These three archetypes cover the core FDE motion.

Can a portfolio help you get a job?

Yes, disproportionately for FDE roles. While a resume gets you past HR, a strong FDE portfolio is what the hiring manager actually evaluates before the interview. It provides the evidence for the decomposition, debugging, and customer empathy rounds. A candidate with a generic CRUD portfolio will be passed over for one with a focused, 3-project FDE portfolio every time.

Should I include a personal website?

Only if it serves as a lightweight container for these three projects and your narrative. A flashy personal site with a particle.js background and a list of technologies you’ve “used” is noise. A single-page site with a clear, one-sentence value proposition (“I turn messy enterprise data into structured APIs”) and links to your three project repos is signal.

How do I prepare for the interview after building the portfolio?

Your portfolio is the source material for your interviews. Practice walking through each project using the narrative framework. Be ready to dive deep on a single technical decision—why you chose Tesseract over a cloud OCR API, or how you handled a specific failure mode. For a tactical breakdown of the FDE interview loop, read: The FDE Interview Loop: Tactical Preparation for the Decomposition and Debugging Rounds.