Forward Deployed Engineer 101: Supply Chain and Logistics (Inventory, Routing, Optimization)

Supply Chain and Logistics (Inventory, Routing, Optimization)

Forward Deployed Engineer (FDE) Study Guide: Supply Chain & Logistics (Inventory, Routing, Optimization)

What This Is

Supply chain and logistics optimization is the backbone of military operations, humanitarian aid, and enterprise resilience. As an FDE, you’ll deploy models, pipelines, and dashboards to track inventory, optimize routes, and predict disruptions—often in austere environments with no cloud access, strict security constraints, or real-time data gaps. Field example: During a disaster response mission, you’re handed a CSV of warehouse stockpiles and a list of delivery routes with no API. You have 48 hours to build a Python script that ingests the data, runs a greedy routing algorithm, and outputs a prioritized manifest for helicopter drops—all while working on a laptop with no internet and a customer who keeps changing the priority zones.

Key Terms & Concepts

• Inventory Optimization: Balancing stock levels to minimize holding costs while avoiding stockouts. Tools: pandas (Python), SQL, SAP IBP (enterprise).
• Vehicle Routing Problem (VRP): Finding the optimal set of routes for a fleet of vehicles to deliver goods. Variants: CVRP (capacitated), VRPTW (time windows), DVRP (dynamic).
• Greedy Algorithms: Fast, heuristic-based solutions (e.g., nearest-neighbor for routing) that trade optimality for speed—critical in low-latency or offline environments.
• Constraint Programming (CP): Modeling problems with hard constraints (e.g., "no truck can exceed 10 tons"). Tools: Google OR-Tools, MiniZinc.
• Air-Gapped Data Pipeline: Moving data between classified and unclassified networks via sneakernet (USB drives, CDs) or one-way diodes. Requires checksum validation and manual logging.
• Last-Mile Delivery: The final leg of delivery, often the most expensive and chaotic (e.g., delivering medical supplies to a conflict zone). Solutions: crowdsourced delivery, drone swarms, or local micro-fulfillment centers.
• Demand Forecasting: Predicting future inventory needs using time-series models (Prophet, ARIMA) or ML (XGBoost). Field trap: Customers often overfit to recent crises (e.g., "We always need 10x more bandages after the last attack").
• Geofencing: Restricting routes or deliveries to specific geographic zones (e.g., "no deliveries within 5km of the border"). Tools: PostGIS, Google Maps API (if internet is available).
• Cold Chain Logistics: Temperature-controlled supply chains (e.g., vaccines, food). Requires IoT sensors (e.g., LoRaWAN) and real-time alerts for deviations.
• Reverse Logistics: Handling returns, recalls, or waste (e.g., expired meds, damaged equipment). Often overlooked but critical for compliance.
• ACO (Ant Colony Optimization): A metaheuristic for routing inspired by ant pheromone trails. Useful for dynamic environments where routes change frequently.
• ATO (Authority to Operate): Security approval for software in government environments. Without it, your model won’t deploy—even if it’s perfect.

Step-by-Step / Field Process

1. Discovery: Separate the "Ask" from the "Infer"

• Action: Run a 30-minute whiteboard session with the customer. Ask:
• "What’s the worst-case scenario if this fails?" (Reveals true constraints.)
• "What’s the simplest thing that could possibly work?" (Avoids over-engineering.)
• "What data do you actually have, not what you wish you had?" (Grounds expectations.)
• Output: A 1-page "Field Hypothesis" doc with:
• The customer’s stated problem ("We need real-time tracking").
• Your inferred problem ("They’re blind to stockouts in Zone B").
• A minimal viable solution (e.g., "A Python script that scrapes their Excel files and emails alerts").

2. Data Ingestion: Assume the Worst

• Action:
• If data is in Excel/CSV: pandas.read_excel("inventory.xlsx", sheet_name=None) (handles multiple sheets).
• If data is in a database: psql -h <customer_db> -U <user> -c "\d" (list tables) → pg_dump -t inventory --data-only > inventory.sql (export).
• If data is on paper: Take photos → OCR with Tesseract (tesseract receipt.jpg output -l eng).
• Field trap: Always validate data before writing code. Run: python df.describe() # Check for negative quantities, NaNs df["timestamp"].max() # Is the data stale?

3. Build the Minimal Solver

• Action:

• For routing: Start with a greedy algorithm (fast, explainable).
  ```python
  from ortools.constraint_solver import routing_enums_pb2
  from ortools.constraint_solver import pywrapcp

  def create_distance_matrix(locations):
  # Replace with real distances (e.g., Haversine)
  return [[0, 10, 15], [10, 0, 20], [15, 20, 0]]

  def main():
  distance_matrix = create_distance_matrix(locations)
  manager = pywrapcp.RoutingIndexManager(len(distance_matrix), 1, 0)
  routing = pywrapcp.RoutingModel(manager)
  transit_callback_index = routing.RegisterTransitCallback(
  lambda from_index, to_index: distance_matrix[from_index][to_index]
  )
  routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
  search_parameters = pywrapcp.DefaultRoutingSearchParameters()
  solution = routing.SolveWithParameters(search_parameters)
  print("Route:", solution) - For inventory: Use a simple reorder-point model.python def reorder_alert(df, threshold=10):
  return df[df["quantity"] < threshold][["item", "quantity"]] ``` - Field trap: Never assume the customer’s constraints are fixed. Ask: "What’s the one rule we can break to make this work?"

4. Deploy in the Customer’s Environment

• Action:
• If air-gapped: Package dependencies with pip download -d ./deps -r requirements.txt → transfer via USB → pip install --no-index --find-links=./deps -r requirements.txt.
• If on-prem: Use Docker (if allowed) or conda-pack for Python environments.
  bash
conda pack -n my_env -o my_env.tar.gz
scp my_env.tar.gz user@customer-server:/tmp
ssh user@customer-server "mkdir -p my_env && tar -xzf /tmp/my_env.tar.gz -C my_env"
• If no Python: Rewrite in Go or Rust for static binaries.
• Field trap: Always test with the customer’s exact data and hardware. A model that runs in 2s on your MacBook might take 20s on their 10-year-old server.

5. Validate and Hand Off

• Action:
• Run a shadow test: Deploy your solution alongside the customer’s existing process and compare outputs for 1 week.
• Create a runbook with:
  • Input/output formats (e.g., "CSV with columns: item_id, quantity, warehouse").
  • Error codes (e.g., "Error 42: Negative quantity detected").
  • Escalation path (e.g., "If the script fails, call [your number] and send the log file").
• Train a local champion: Identify 1-2 customer staff who can run the tool without you.

Common Mistakes

FDE Interview / War Story Insights

1. The "We Need This Yesterday" Scenario

• Interviewer: "The customer’s warehouse is burning down, and they need a real-time inventory tracker in 2 hours. What do you do?"
• Answer:
• Clarify the ask: "Do you need real-time (e.g., RFID tags) or near-real-time (e.g., a script that scrapes their existing system every 5 minutes)?"
• Leverage existing tools: "Can we use your current barcode scanners + a Google Sheet with Apps Script?"
• Deliver a manual workaround first: "Here’s a checklist for staff to call out stock levels every 15 minutes. We’ll automate it later."
• Why: The customer doesn’t care about your tech stack—they care about the mission.

2. The "Scope Creep" Trap

• Interviewer: "The customer demands a feature that wasn’t in the original scope. How do you respond?"
• Answer:
• Acknowledge the ask: "I understand why this is important—let’s discuss tradeoffs."
• Frame as a cost/benefit: "Adding this will delay the core feature by 2 weeks. Is that acceptable?"
• Offer a minimal alternative: "We can build a lightweight version of this in 2 days. Would that work?"
• Why: Customers will always ask for more. Your job is to protect the mission.

3. The "No Data" Problem

• Interviewer: "The customer has no digital inventory records—just paper logs. How do you proceed?"
• Answer:
• Digitize manually: "We’ll hire a temp to input the last 3 months of logs into a spreadsheet."
• Build a stopgap: "Here’s a mobile app for staff to scan barcodes with their phones."
• Plan for the future: "Let’s install RFID tags on new shipments so this doesn’t happen again."
• Why: In the field, you work with what you have—not what you wish you had.

Quick Check Questions

1. You’re deploying a routing algorithm to a classified network with no internet access. The customer’s security team won’t allow Docker. What’s your first step?

• Answer: Package the app as a static binary (e.g., PyInstaller for Python, Cargo build --release for Rust) and transfer it via approved media (e.g., CD-ROM).
• Why: Static binaries have no external dependencies, making them easier to approve for air-gapped environments.

2. The customer’s inventory data is in 50 Excel files with inconsistent formats. How do you standardize it quickly?

• Answer: Write a Python script with pandas to: python dfs = [] for file in glob.glob("*.xlsx"):
df = pd.read_excel(file, sheet_name=0)
df["source_file"] = file # Track origin
dfs.append(df) combined = pd.concat(dfs, ignore_index=True) combined.to_csv("standardized_inventory.csv", index=False)
• Why: Automate the boring stuff—manual cleanup is error-prone and slow.

3. A humanitarian aid organization needs to deliver supplies to 100 villages, but some roads are impassable due to flooding. How do you adjust the routes?

• Answer:
• Get real-time road data: Use satellite imagery (e.g., Sentinel-2) or crowd-sourced reports (e.g., OpenStreetMap).
• Update the distance matrix: Set impassable roads to infinity in your VRP solver.
• Fallback to drones/boats: If roads are blocked, reroute to alternative transport modes.
• Why: Dynamic environments require dynamic solutions.

Last-Minute Cram Sheet

1. Key Python libraries: pandas (data), ortools (routing), Prophet (forecasting), geopy (distances).
2. Key commands:
3. pip download -d ./deps -r requirements.txt (air-gapped deps)
4. conda pack -n my_env -o my_env.tar.gz (portable Python env)
5. tesseract receipt.jpg output -l eng (OCR for paper data)
6. Common ports:
7. 5432 (PostgreSQL), 3306 (MySQL), 6379 (Redis)
8. Field traps:
9. ⚠️ Always validate data before modeling. Garbage in = garbage out.
10. ⚠️ Test in the customer’s environment. Your laptop ≠ their server.
11. ⚠️ Document failure modes. Assume your tool will break at 3 AM.
12. Acronyms:
13. VRP: Vehicle Routing Problem
14. CVRP: Capacitated VRP
15. VRPTW: VRP with Time Windows
16. ACO: Ant Colony Optimization
17. ATO: Authority to Operate
18. IAM: Identity and Access Management
19. Greedy routing pseudocode:
    python
def greedy_route(locations, start):
unvisited = set(locations)
route = [start]
unvisited.remove(start)
while unvisited:
next_stop = min(unvisited, key=lambda x: distance(route[-1], x))
route.append(next_stop)
unvisited.remove(next_stop)
return route
20. Haversine distance (for routing):
    python
from math import radians, sin, cos, sqrt, atan2
def haversine(lat1, lon1, lat2, lon2):
R = 6371 # Earth radius in km
dLat = radians(lat2 - lat1)
dLon = radians(lon2 - lon1)
a = sin(dLat/2) * sin(dLat/2) + cos(radians(lat1)) * cos(radians(lat2)) * sin(dLon/2) * sin(dLon/2)
c = 2 * atan2(sqrt(a), sqrt(1-a))
return R * c
21. Inventory reorder point formula:
    Reorder Point = (Daily Demand × Lead Time) + Safety Stock
22. Cold chain alert threshold: Typically ±2°C from target (e.g., vaccines at 2–8°C).
23. Reverse logistics rule of thumb: ~10–30% of forward logistics costs (e.g., returns, recalls).