Open Source · Built with Claude Code

Carrier Demo Factory

An autonomous agent pipeline that turns a folder of trucking company CSVs into a complete sales demo — insights report, company profile, and a working ops platform — with no human steps between input and output.

Input
CSV Data
Drop in a carrier's operational CSV exports
Phase 2
Analysis
Claude independently discovers pain points like a consultant
Phase 3
Report
Self-contained HTML insights report with Plotly charts
Phase 3.5
Profile
Company profile page — story, data, findings, products
Phase 4
Platform
Multi-page Streamlit operations platform, deployed live
Loading demos…

Project Overview

Carrier Demo Factory is an autonomous agent pipeline that turns a folder of trucking company CSVs into a complete, deployed sales demo — with no human steps between input and output. One command triggers a five-phase Claude Code pipeline that generates synthetic operational data, analyzes it like a consultant, produces three polished deliverables, deploys them to a live VPS, and updates the portfolio page automatically.

The project was built to solve a real sales problem: how do you walk into a cold meeting with a trucking company and immediately demonstrate that you understand their business better than they do? The answer is to show up with a working product already built for them — not a deck, not a mockup, but a live platform running on their own numbers. Every demo is unique because every dataset tells a different story.

What This Demonstrates

Engineering Decisions

  • Designed a multi-phase state machine so each Claude Code session has a narrow, well-scoped task — preventing context overflow and making failures recoverable
  • Used Claude Code's agentic loop to write, execute, and iterate on Python analysis scripts rather than pre-scripting any analysis logic
  • Chose Caddy over nginx for automatic HTTPS and minimal config — the agent can write valid Caddyfile blocks without needing SSL cert management
  • Kept every deliverable self-contained (standalone HTML, standalone Streamlit app) so nothing breaks if one component fails
  • Built a companies.json state file updated by deploy scripts so the portfolio page never requires a manual edit

Problem-Solving Process

  1. Sales-first design: Mapped the three deliverables to the actual stages of a B2B sales cycle before writing a line of code
  2. Prompt scoping: Broke a complex end-to-end pipeline into five focused prompts, each owning exactly one phase with a clear input and output contract
  3. Autonomous analysis: Instructed Claude to explore the data freely and write its own analysis scripts rather than following a fixed template — producing findings specific to each dataset
  4. State recovery: Built current_state.txt as a simple checkpoint so a failed phase can be retried without rerunning the entire pipeline
  5. Local/VPS parity: Created parallel run-local.sh and run-cycle.sh scripts with identical logic, only differing in whether deploy steps are executed

Professional Outcome

  • End-to-end autonomous pipeline from raw CSV to live public URL with zero manual steps
  • Practical experience designing multi-phase agentic systems with real failure recovery
  • Production infrastructure: systemd services, Caddy reverse proxy, HTTPS, VPS deployment
  • Demonstrates ability to translate a business problem (sales demos) into a technical architecture and ship it independently

Key Features

Insights Report

A self-contained HTML file with Plotly charts covering every major pain point. No login required — built to be emailed to the prospect, their accountant, or their bank before the pitch even begins.

Company Profile Page

A public-facing profile that tells the company's story, surfaces key stats, and frames pain points in plain language. Designed to create recognition — the prospect feels understood before they see a product.

Live Ops Platform

A multi-page Streamlit application deployed over HTTPS and running on the prospect's actual data. Not a mockup — a working product accessible from any device before the sales call starts.

Real Analysis, Not Templates

Claude writes its own Python analysis scripts and follows threads in the data independently. Every demo surfaces different pain points because every dataset is different — nothing is hard-coded.

Full Deployment Automation

The agent registers systemd services, writes Caddy reverse proxy routes, serves everything over HTTPS, and updates the portfolio JSON — no manual infrastructure steps after the pipeline runs.

Four Carrier Types

The pipeline generates demos for owner-operators, small fleets, regional carriers, and mid-size carriers — each with carrier-appropriate data volumes, pain patterns, and platform feature sets.

How It Works

The pipeline is driven by a bash state machine (run-cycle.sh) that advances through five phases, invoking Claude Code with a scoped prompt at each step:

  1. Company Creator: Generates a realistic carrier identity — name, location, fleet size, owner background, freight lanes — and writes it to company_profile.md
  2. Idea Generator: Reads the profile and the raw CSVs, writes and runs Python scripts to explore the data, and produces a structured list of pain points with exact figures
  3. Report Builder: Takes the pain point findings and builds a self-contained HTML insights report with embedded Plotly charts and a narrative around each finding
  4. Profile Builder: Produces the public-facing company profile page — story, stat strip, pain cards, and product cards linking to the report and ops platform
  5. Ops Builder: Writes a multi-page Streamlit app covering fleet KPIs, load board, cash flow, driver scorecards, and a getting-started guide — then calls deploy-app.sh to register and start it

Each phase reads outputs from the previous phase and writes its own outputs to a company directory. The state machine tracks the current phase in current_state.txt — if a phase fails, the pipeline restarts from that phase, not from the beginning.

Tech Stack

Claude Code Python 3.12 Streamlit Pandas Plotly Bash Caddy systemd HTML/CSS/JS Ubuntu VPS

Skills Demonstrated

  • Multi-phase agentic AI system design with state machine and failure recovery
  • Prompt engineering for scoped, autonomous Claude Code sessions
  • End-to-end pipeline architecture from raw data to deployed public URL
  • Linux server administration: systemd, Caddy, HTTPS, reverse proxy configuration
  • Python data analysis and visualization (Pandas, Plotly, exploratory scripting)
  • Full-stack web delivery: self-contained HTML reports, Streamlit apps, static portfolio pages
  • Translating a B2B sales motion into a technical product architecture
  • Independent end-to-end product delivery — concept to live demo