The FDE Portfolio: 4 Projects to Prove You Can Ship in the Customer's Chaos

Why 'Beautiful' Portfolios Get Ignored

A standard software engineering portfolio showcases pristine architecture. It assumes clean APIs, stable schemas, and well-defined requirements. A Forward Deployed Engineer (FDE) never sees these. You are parachuted into a customer’s messy warehouse, a bank’s legacy mainframe, or a defense contractor’s air-gapped network. The data is malformed. The API is rate-limited to 1 request per second. The documentation is a lie.

If your portfolio is a weather app or a pixel-perfect landing page, you are signaling that you can paint by numbers. FDE hiring managers at Palantir, Scale AI, or Anduril are looking for a different signal: can you ship in the chaos?

This playbook outlines four concrete projects that simulate the actual work of an FDE. These are not tutorials. They are scenarios designed to break. Build these, write up the failures, and you will skip the resume pile.

The FDE Signal Stack: Speed, Taste, Data Wrangling

Before writing code, understand the evaluation rubric. FDE interviews are not about algorithmic complexity (you won't invert a binary tree on a customer site). They measure three things, as detailed in our guide on The Highest-Leverage Skills for an FDE in the AI Era: Speed, Taste, and Data Wrangling:

1. Speed: Can you go from a verbal problem statement to a working prototype in 2 hours?
2. Taste: Can you build a UI that an overwhelmed operations analyst will trust, not just tolerate?
3. Data Wrangling: Can you normalize a 50MB CSV with inconsistent date formats and null terminators without panicking?

The following projects force you to exercise these muscles against realistic resistance.

Project 1: The 'Broken Pipe' Integration

Scenario: A logistics customer has a legacy on-premise system that dumps shipment data to a shared network drive every hour. The files are poorly formatted CSVs with byte-order marks (BOM) and random empty rows. You need to ingest this, join it against a modern REST API (e.g., a weather service), and surface the data in a usable interface.

The Build:

• Ingestion: Write a Python script that watches a local directory (simulate the network drive). Use codecs to strip BOM characters and pandas to handle ragged rows. Do not use csv module defaults; they will choke.
• API Integration: Pick a free API (Open-Meteo is great). The trick: the legacy system uses standard time, the API uses ISO 8601. You must handle the mapping. Introduce intentional 429 rate limiting and implement exponential backoff.
• UI: Build a minimal Streamlit or Next.js dashboard showing a table of shipments with a "Delay Risk" column calculated by joining shipment location with real-time weather data.

The FDE Signal: This project proves you can handle dirty data at the edge. You aren't just calling fetch(); you are bridging a 1990s file dump to a modern cloud API. Write in your README exactly where the data broke and how you fixed it.

Project 2: The 'Production Forensics' Dashboard

Scenario: A customer reports that their billing system is "acting slow." You have no direct access to their servers, only a raw stream of structured logs they exported for you. You must diagnose the bottleneck without running local code on their system.

The Build:

• Data Simulation: Write a script that generates 100,000 fake log lines. Inject a subtle pattern: 2% of requests to a specific endpoint (/api/invoice/generate) have a latency spike (5000ms) correlated with a specific payload size (>10KB).
• Analysis: Do not load this into a database. Use command-line tools and scripting (grep, awk, jq, or a Python script using generators) to parse the stream. Identify the exact endpoint and the payload threshold.
• Visualization: Create a static HTML report (no server required) that shows a histogram of request latencies, highlights the problematic endpoint, and shows the correlation between payload size and latency. Use Vega-Lite embedded in a single HTML file.

The FDE Signal: FDEs rarely get to install the "good tools" like Datadog on day one. This project demonstrates you can fly blind with a terminal and a text editor. It shows you understand latency distributions, not just averages. For a deeper look at the day-to-day reality of this work, read What a Forward Deployed Engineer Actually Does in a Week: A Chronological Deep Dive.

Project 3: The 'Zero-Click' Workflow Automator

Scenario: An operations team manually checks a vendor portal every morning, downloads a PDF report, extracts a specific table, and emails it to their boss. This is a waste of an analyst’s time. You have 1 hour to automate it.

The Build:

• Automation Engine: Use n8n (self-hosted) or a Python script with Playwright. Do not use an API if one exists; the point is to simulate the worst-case scenario of screen-scraping a legacy portal.
• Document AI: Use a free vision LLM (e.g., Gemini Flash free tier via OpenRouter) to parse the downloaded PDF. See our guide on Generate Anki Flashcards from Lecture PDFs Using Gemini Flash API Free Tier for context on structuring unstructured document extraction. The table will have merged cells. Your prompt must handle this.
• Delivery: Format the extracted table as a clean HTML email and send it via SMTP. Include error handling: if the portal is down, the script should retry and eventually send an alert email with the stack trace.

The FDE Signal: This proves you can ship a "good enough" solution immediately. It combines RPA (Robotic Process Automation) with modern LLM tooling. The key metric here is wall-clock time to value.

Project 4: The 'Black Box' Wrapper

Scenario: You are given an open-source ML model (e.g., Whisper for transcription) that the customer wants to use, but their data is sensitive and cannot leave their VPC. You need to wrap this model in a lightweight API that mimics a SaaS provider, allowing their legacy apps to use it without modification.

The Build:

• Wrapping: Create a FastAPI server that wraps faster-whisper. The tricky part: the legacy app sends audio in GSM 6.10 format (old phone systems), but Whisper expects WAV. You must implement a conversion layer using ffmpeg-python.
• API Compatibility: The legacy app currently points to a deprecated SaaS endpoint. You must match the exact request/response JSON schema of that deprecated API, including its weird error codes, so the customer doesn't have to change a single line of their code.
• Deployment: Package this as a single Docker container. Write a docker-compose.yml that spins up the entire stack. Include a health check endpoint that verifies ffmpeg is accessible and the model is loaded.

The FDE Signal: FDEs often build "adapters" to bridge modern AI to ancient infrastructure. This project demonstrates systems thinking and a deep understanding of API design as a contract. It’s the ultimate act of taste: hiding complexity behind a familiar interface.

How to Present Chaos to a Hiring Manager

Do not just link a GitHub repo. The narrative is the product.

1. The README is your post-mortem: Do not write "How to run." Write a blog-style narrative. Include a section titled "Where it broke." Example: "The CSV parser crashed on row 14,503 because of an unexpected \x00 character. I patched it by switching to a binary stream reader."
2. Video Evidence: Record a 2-minute Loom video. Show the project working, then intentionally trigger a failure (e.g., pull the network cable) and show how your code handles it gracefully. FDE work is about resilience, not perfection.
3. Speed Metrics: At the top of the README, put: Time to ship: 3.5 hours. This signals self-awareness and efficiency.

If you want to practice rapid prototyping under time pressure, check out our build guide: Build a Screenshot-to-Code Agent Using Groq Vision & Vercel in 30 Minutes. It’s a perfect warm-up for the speed component of the FDE skill stack.

FAQ

How to get into an FDE role? Stop optimizing for pure software engineering interviews. Build projects that touch hardware, legacy formats, or customer workflows. Network by solving problems for people in your target industry before they hire you. Write a white paper, not a resume.

How to build a front-end developer portfolio for FDE? Don’t build a portfolio site; build a portfolio of interventions. A traditional front-end portfolio shows visual polish. An FDE portfolio shows a React interface that gracefully degrades when the backend returns a 500 error, or a UI that renders a 10,000-row table without crashing the browser. It’s less about the CSS and more about the state management under duress.

What should you include in your career portfolio? Include artifacts of salvage. A project where you took a broken internal tool and rebuilt it. A data migration script that handled edge cases the original engineers missed. A dashboard that exposed a $100k billing error. Include the "before" state. The messier the "before," the stronger the signal.

Is FDE a sales role? No, but it is a technical trust-building role. You don't carry a quota, but you are often the reason a deal expands. You sit side-by-side with the customer’s engineers, identify the "hair on fire" problem, and solve it with code within the trial period. You convert technical skepticism into technical adoption.