# Day 2: User Journey Mastery — Every Path, Every Moment

**Date:** 2026-03-10
**Retreat:** 7-Day Advisory Council Strategic Retreat
**Session Lead:** Elena Marchetti (UX), with contributions from all 12 advisors
**Purpose:** Map ALL user journeys with micro-detail. These are the north star.

---

## Annotation Legend

- Emotion: `DELIGHT` / `NEUTRAL` / `FRICTION` / `RAGE-QUIT RISK`
- Time: seconds or minutes
- Critical Path: `CRITICAL` / `OPTIONAL`
- Advisor flags: [YUKI] latency concerns, [MARCUS] acquisition funnel, [AMARA] community moments, [ELENA] UX friction

---

## Journey 1: Dev Anya — First 30 Minutes
**Persona:** Solo developer, RTX 4090, $200/mo OpenAI bill, heard about LLMHosts on r/LocalLLaMA
**Hardware:** Desktop PC, Windows 11, 64GB RAM, RTX 4090 24GB, 1TB NVMe
**Goal:** Stop paying OpenAI; use home GPU instead

### Phase A: Discovery (T-5 minutes to T=0)

**Step A1: Reddit discovery**
- Anya sees a post: "I cut my OpenAI bill from $300/mo to $18/mo with this"
- Link goes to LLMHosts.com landing page
- Emotion: `CURIOUS` | Time: 30 seconds | Critical: CRITICAL
- [MARCUS]: This is the acquisition moment. The headline on the landing page must show a dollar amount, not a feature list.
- [AMARA]: The Reddit post is our most powerful acquisition channel. r/LocalLLaMA has 266K+ members. We must have community members who post authentic stories.

**Step A2: Landing page first impression**
- Above fold: "Your RTX 4090 earns $0.018 per request serving GPT-4-class AI. OpenAI charges you $10/M tokens. LLMHosts charges you $0."
- She sees: [Install] button, a live savings counter ($142,847 saved by LLMHosts users today)
- Emotion: `INTRIGUED` | Time: 20 seconds | Critical: CRITICAL
- [ELENA]: The live savings counter is a social proof mechanism. It must be real data, not fake. If it's fake, power users will detect it and post about it.

**Step A3: Decision to install**
- She copies the install command: `pip install llmhosts`
- Emotion: `COMMITTED` | Time: 10 seconds | Critical: CRITICAL

---

### Phase B: Installation (T=0 to T=3 minutes)

**Step B1: pip install llmhosts**
```
pip install llmhosts
Collecting llmhosts
  Downloading llmhosts-0.6.0-cp312-cp312-win_amd64.whl (18.4 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 18.4/18.4 MB 12.3 MB/s eta 0:00:00
Successfully installed llmhosts-0.6.0
```
- Emotion: `NEUTRAL` | Time: 90 seconds | Critical: CRITICAL
- [YUKI]: The wheel must be <20MB. If it requires a 2GB download, half of users abandon here.
- [DR. HANS]: The maturin-built Rust binary is what makes the wheel platform-specific. The CUDA variant ships with the cudarc compute path pre-compiled.

**Step B2: llmhosts up (Phase 1: Assess)**
```
Phase 1: Assessing hardware...
  GPU: NVIDIA GeForce RTX 4090 (24.0 GB VRAM)  ✓
  RAM: 64 GB                                    ✓
  OS:  Windows 11                               ✓

  Recommended model: Llama 3.3 70B Q4_K_M
    Expected performance: ~47 tokens/second
    VRAM usage: 22.1 GB / 24.0 GB
    Download size: 42 GB
```
- Emotion: `DELIGHT` | Time: 3 seconds | Critical: CRITICAL
- [ELENA]: The "42 GB download" is a FRICTION moment. We must immediately follow it with a time estimate and an alternative option.
- [AMARA]: This is the first "aha moment" — seeing her specific GPU recognized and a specific recommendation. This should be shareable ("Look what it detected!").

**Step B3: Model selection prompt**
```
  This model requires a 42 GB download (~35 minutes on typical connection).

  Alternatives for faster start:
  [Q] Qwen 2.5 7B Q5_K_M  — 4.4 GB download (3 min), 180 tok/s  ← FAST START
  [L] Llama 3.3 70B Q4_K_M — 42 GB download (35 min), 47 tok/s
  [S] Skip model download (I have a model already)

  Selection [Q/L/S, default=Q]:
```
- Emotion: `NEUTRAL` | Time: 15 seconds | Critical: CRITICAL
- [ELENA]: The default must be the fast option. Most users will take the default. The 42GB download is a context-switching killer.
- [YUKI]: The 7B model at 180 tok/s is actually a better TTFT experience than the 70B at 47 tok/s. The larger model only wins on quality. For most first-run tasks, quality difference is imperceptible.

**Step B4: Model download (if 7B selected)**
```
Phase 2: Provisioning model...
  Downloading qwen2.5-7b-instruct-q5_k_m.gguf (4.4 GB)
  [=========================>    ] 87%  38 MB/s  ETA: 18 seconds
```
- Emotion: `ANTICIPATION` | Time: 3 minutes | Critical: CRITICAL
- [DR. PRIYA]: Chunked download with resume capability is essential. If the download fails at 80%, the user must not restart from zero.
- [ELENA]: The progress bar must show ETA in seconds, not percent. Percent is meaningless; seconds tells users when to come back.

---

### Phase C: Startup (T=3 to T=5 minutes)

**Step C1: Model load into LLMHosts Core**
```
Phase 3: Loading model...
  Loading qwen2.5-7b-instruct-q5_k_m.gguf into LLMHosts Core...
  CUDA backend: RTX 4090 selected
  KV cache allocated: 2.1 GB
  Model ready: 180 tokens/second capacity
```
- Emotion: `DELIGHT` | Time: 8 seconds | Critical: CRITICAL
- [DR. HANS]: The "180 tokens/second capacity" display is a promise. We must be within 10% of this figure in real usage, or users will feel deceived.

**Step C2: Authentication (device code flow)**
```
Phase 4: Connecting to LLMHosts.com...
  Open this URL in your browser to authenticate:
  https://llmhosts.com/device?code=WXYZ-ABCD

  Waiting for authentication... (opens automatically in 3 seconds)
```
- Emotion: `MILD FRICTION` | Time: 20 seconds | Critical: CRITICAL
- [ELENA]: The browser should open automatically. If it doesn't (Windows popup blocker), the code must be visible and copyable. The UX failure mode here causes 15-20% drop-off.
- [MARCUS]: Authentication at install is a conversion point. We should offer "continue without account" for the first 24 hours, with a banner showing what account features unlock.

**Step C3: Proxy started**
```
Phase 5: Starting proxy...
  ┌─────────────────────────────────────────────────────┐
  │  LLMHosts is running                                 │
  │                                                      │
  │  API endpoint: http://localhost:11400/v1             │
  │  Model: Qwen 2.5 7B (180 tok/s, RTX 4090)          │
  │                                                      │
  │  To use with Cursor or VS Code:                     │
  │  OPENAI_BASE_URL=http://localhost:11400/v1           │
  │  OPENAI_API_KEY=any-value (auth not required locally)│
  │                                                      │
  │  Dashboard: https://llmhosts.com/dashboard          │
  │  Savings:   $0.00 saved today (make your first call) │
  └─────────────────────────────────────────────────────┘
```
- Emotion: `DELIGHT` | Time: 2 seconds | Critical: CRITICAL
- [ELENA]: This terminal display is the "aha moment" for most users. It must be beautiful. Not just functional — beautiful. ASCII art borders, color, precise alignment.
- [AMARA]: The "make your first call" prompt is a completion hook. Users who make their first API call within 5 minutes have 3× higher 30-day retention.

---

### Phase D: First API Call (T=5 to T=8 minutes)

**Step D1: Test call from terminal**
```bash
curl http://localhost:11400/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "auto", "messages": [{"role": "user", "content": "Hello"}], "stream": false}'
```

**Step D2: Response received**
```json
{
  "id": "chatcmpl-01J9X...",
  "object": "chat.completion",
  "model": "qwen2.5-7b-instruct-q5_k_m",
  "choices": [{
    "message": {"role": "assistant", "content": "Hello! I'm running locally on your RTX 4090 at 178 tokens/second. No cloud, no cost."},
    "finish_reason": "stop"
  }],
  "usage": {"prompt_tokens": 5, "completion_tokens": 22, "total_tokens": 27}
}
```
- Headers: `X-LLMHosts-Cost: $0.000 | X-LLMHosts-Backend: local | X-LLMHosts-Latency-Ms: 287`
- Emotion: `DELIGHT` | Time: 3 seconds | Critical: CRITICAL
- [ELENA]: The first response must mention "running locally" and "no cost" — reinforce the value prop in the response content itself during the first call detection.
- [YUKI]: 287ms TTFT for a 7B model is excellent. Our target is <100ms for first token. 287ms suggests tokenization overhead. Investigate: py→rust call, tokenizer, GPU launch.

**Step D3: Dashboard update**
- LLMHosts.com dashboard shows: "1 request | 22 tokens | $0.00 saved vs cloud ($0.00022 would have cost on OpenAI)"
- Emotion: `DELIGHT` | Time: instant | Critical: IMPORTANT
- [MARCUS]: The savings number is tiny ($0.00022) but the dashboard must frame it as: "At this rate, you'll save $8.10/month." Project it forward. Make it feel meaningful.

---

### Phase E: Integration with Cursor/VS Code (T=8 to T=15 minutes)

**Step E1: Setting env vars**
- Anya sets `OPENAI_BASE_URL=http://localhost:11400/v1` in Cursor's AI settings
- Emotion: `NEUTRAL` | Time: 2 minutes | Critical: CRITICAL
- [ELENA]: We must provide a one-click "Configure Cursor" button in the dashboard that auto-patches Cursor's settings.json via a deep link. Manual env var setting causes 30% drop-off here.

**Step E2: First Cursor AI request**
- Anya uses Cursor's command palette, asks a coding question
- Response: 178 tokens/second, essentially instant for a typical response
- Emotion: `DELIGHT` | Time: 3 seconds | Critical: CRITICAL
- [AMARA]: "Cursor is using my GPU" — this is the moment users post on Reddit. Capture it. "Take a screenshot and share your setup" prompt in the dashboard.

---

## Journey 2: Remote GPU Access — Coffee Shop Scenario
**Persona:** Anya, 2 weeks after first install, at a coffee shop with her laptop
**Goal:** Use home RTX 4090 from laptop over internet

### Journey Map

| Step | What Happens | Emotion | Time | Critical |
|------|-------------|---------|------|----------|
| 1 | Opens laptop at coffee shop, opens Cursor | NEUTRAL | 5s | — |
| 2 | Cursor hits localhost:11400 — connection refused | FRICTION | 1s | CRITICAL |
| 3 | Token assistant in LLMHosts dashboard: "Your GPU is at home. Enable remote access?" | NEUTRAL | — | CRITICAL |
| 4 | Anya clicks "Enable Remote Access" → llmhosts tunnel start | ANTICIPATION | 10s | CRITICAL |
| 5 | Tunnel connects to relay server (M1 WSS, future M2 + Noise NK) | NEUTRAL | 3s | CRITICAL |
| 6 | Dashboard shows: "Remote endpoint: https://relay.llmhosts.com/u/anya-abc123" | DELIGHT | instant | CRITICAL |
| 7 | Sets OPENAI_BASE_URL to relay endpoint | NEUTRAL | 30s | CRITICAL |
| 8 | Cursor makes request → relay → home GPU → response | DELIGHT | 150ms overhead | CRITICAL |
| 9 | Sees: "Request routed via relay to your RTX 4090 (home). Latency: 147ms added by tunnel." | NEUTRAL | instant | IMPORTANT |
| 10 | Continues working; tunnel is transparent | DELIGHT | ongoing | — |

**Key failure modes:**
- Relay down: fallback to cloud with user consent prompt
- Home machine asleep: "Your home machine appears offline. Wake it up at llmhosts.com/wake-on-lan"
- Residential ISP NAT: relay handles this transparently (no port forwarding needed)
- Coffee shop WiFi blocks WebSockets: relay must fall back to HTTP long-polling

**AHA Moment:** "I'm at Starbucks and my GPU at home is answering my coding questions." This is the conversion trigger from Free to Pro ($19/mo). The relay paywall must appear here if the user is on the free plan.

**Paywall UX:** "Remote access requires LLMHosts Pro ($19/mo). You're currently saving $200/month by using your GPU. Remote access lets you keep saving while you travel. [Start Free Trial] [Maybe Later]"

---

## Journey 3: Operator First Marketplace Booking
**Persona:** Marcus, power user, RTX 4090, has been running LLMHosts for 3 months
**Goal:** Earn money from idle GPU time

### Phase A: Enabling Marketplace (Day 1 as operator)

| Step | Action | Emotion | Time |
|------|--------|---------|------|
| 1 | Dashboard: "Your GPU earned $0 last month. Enable Marketplace to earn $40-80/month." | INTRIGUED | — |
| 2 | Clicks "Enable Marketplace" | COMMITTED | 5s |
| 3 | Stripe Connect onboarding (KYC: name, bank account) | FRICTION | 8-12 minutes |
| 4 | Sets pricing: $0.15/M tokens, available hours: 10pm-8am + weekends | NEUTRAL | 3 minutes |
| 5 | Sets capacity: max 4 concurrent requests, VRAM allocation 20GB | NEUTRAL | 2 minutes |
| 6 | GPU goes live on marketplace | DELIGHT | instant |
| 7 | Dashboard: "Your node is live. 0 requests this hour. Estimated monthly: $12 at current fleet utilization." | MILD DISAPPOINTMENT | — |

**Cold Start Problem (Days 1-7):**
- [FATIMA]: The cold-start period is the biggest operator churn trigger. We must show intermediate signals. Day 1: "Your node has been seen by 47 potential buyers." Day 3: "Your node was queued once but another node was selected (lower latency). Consider lowering price or expanding hours." Day 7: "First booking! 23 tokens served."
- [MARCUS]: The $12/month estimate is demotivating if it feels low. The dashboard must show the compounding effect: "As our marketplace grows, your estimated monthly will grow. Current fleet is 847 operators; target is 5,000 by Q4 2026."

**First Payout Signal (Day 14-21):**
```
Notification: Your GPU served its first paid request!
  User: anonymous
  Tokens: 3,847
  Earned: $0.58
  Your 80% share: $0.46
  Platform 20%: $0.12

  Your first payout will process on [date] (~14 days after first earning).
```
- Emotion: `DELIGHT` (despite small amount) | Critical: VERY HIGH
- [ZARA]: This notification must be celebratory, not transactional. "Your first dollar is incoming! 🎉" Frame it as a milestone, not an invoice.

---

## Journey 4: Enterprise Team Fleet Deployment
**Persona:** Tomas, engineering lead at a 50-person startup, 5 developer workstations with RTX 4090s
**Goal:** Centralize AI inference across team, eliminate $5,000/month cloud API bill

### Fleet Provisioning Map

| Step | Action | Actors | Time | Friction Level |
|------|--------|--------|------|---------------|
| 1 | Tomas creates Enterprise account at llmhosts.com | Tomas | 5 min | LOW |
| 2 | Creates API key for team with rate limits | Tomas | 2 min | LOW |
| 3 | `pip install llmhosts && llmhosts up --team-key=<key>` on machine 1 | Dev 1 | 8 min | LOW |
| 4 | Machine appears in Tomas's fleet dashboard | Tomas | instant | — |
| 5 | Repeats step 3-4 for machines 2-5 | Devs | 35 min total | LOW |
| 6 | Fleet dashboard shows: 5 nodes, 120 GB total VRAM, 250 tok/s aggregate capacity | Tomas | instant | — |
| 7 | Configures RBAC: Dev A has access to nodes 1-3 only | Tomas | 5 min | MEDIUM |
| 8 | Sets billing: consolidated invoice to company credit card | Tomas | 3 min | MEDIUM |
| 9 | Shares team endpoint: `http://team.llmhosts.internal/v1` | Tomas | 1 min | LOW |
| 10 | Devs update OPENAI_BASE_URL in their tools | All devs | 2 min each | LOW |
| 11 | First day: team makes 2,400 requests, saves $4.80 vs cloud | Everyone | — | DELIGHT |

**Key Enterprise Features Required:**
- Centralized billing (one invoice, not per-machine)
- RBAC (who can access which machines)
- Audit log (what was asked, which machine served it, cost)
- SSO (SAML/OIDC — critical for enterprise security teams)
- SLA dashboard (uptime per node, P99 latency across fleet)
- Model pinning (enforce specific models for compliance)

**ELENA:** The fleet dashboard is the product for enterprise buyers. It must show: total savings, requests per day, top users, model distribution, node health. If Tomas can't explain to his CTO why LLMHosts is worth using vs. just paying OpenAI, churn happens at month 3.

---

## Journey 5: API Consumer Building an App on LLMHosts
**Persona:** Sarah, independent developer building a writing assistant SaaS
**Goal:** Use LLMHosts as her AI backend to avoid cloud API costs for her own SaaS

### Journey Map

| Step | Action | Emotion | Time |
|------|--------|---------|------|
| 1 | Discovers LLMHosts marketplace API (docs page) | CURIOUS | — |
| 2 | Creates account, gets API key | NEUTRAL | 3 min |
| 3 | npm install openai; sets baseURL to LLMHosts marketplace endpoint | NEUTRAL | 5 min |
| 4 | First request: routes to marketplace node, 127ms TTFT | DELIGHT | 10s |
| 5 | Scales to 100 concurrent users: marketplace handles it via request distribution | DELIGHT | ongoing |
| 6 | Node goes offline: request fails, returns 503 | FRICTION | — |
| 7 | Discovers: LLMHosts has automatic failover to cloud BYOK — sets OpenAI API key | RELIEF | 2 min |
| 8 | Node availability: SLA is 95.5% — below enterprise expectations | CONCERN | — |
| 9 | Upgrades to "Verified Nodes Only" tier at 2× price — 99.2% SLA | ACCEPTABLE | 2 min |
| 10 | Month 3: serves 50M tokens for $5,000 (vs $7,500 on OpenAI Tier 2) | DELIGHT | — |

**Key concerns for API consumers:**
- SLA guarantees (marketplace nodes are consumer hardware — reliability varies)
- Cold start latency (model must be pre-loaded on node)
- Model consistency (same model, different quantization = different outputs)
- Rate limits (need per-key billing and limits)
- Pricing predictability (marketplace prices can fluctuate)

**[DR. RAFAEL]:** The API consumer journey reveals that LLMHosts needs a "stable API contract" even if the backend is dynamic. The consumer must not need to know which physical node served their request. Load balancing, failover, and retry must be transparent.

---

## Journey 6: Fine-Tuning User (Wave 5)
**Persona:** Dr. Chen, ML engineer at a legal firm, wants a model fine-tuned on legal contracts
**Goal:** From "I want to fine-tune on my data" to "my custom model is live"

### Journey Map (Wave 5 — 2026 Q4)

| Step | Command / Action | Emotion | Time |
|------|-----------------|---------|------|
| 1 | `llmhosts finetune prepare --input ./contracts/ --format jsonl` | NEUTRAL | 5 min |
| 2 | 847 documents parsed, 12,340 training examples generated | NEUTRAL | 3 min |
| 3 | `llmhosts finetune train --base llama3.1:8b --dataset ./data.jsonl --epochs 3` | COMMITTED | 15s |
| 4 | Training starts on RTX 4090: "Est. completion: 14 hours" | ANTICIPATION | — |
| 5 | Training progress: epoch 1/3 at 35% | NEUTRAL | 4.5 hrs |
| 6 | Warning: "Loss plateau detected. Consider reducing learning rate or increasing warmup steps." | SURPRISE (helpful) | — |
| 7 | Training complete. Adapter saved: `~/.llmhosts/adapters/legal-v1.gguf` | DELIGHT | 14 hrs |
| 8 | `llmhosts deploy --adapter legal-v1` | NEUTRAL | 30s |
| 9 | "Your custom model is live: http://localhost:11400/v1 (model: llama3.1-8b-legal-v1)" | DELIGHT | instant |
| 10 | Tests with a contract question — model correctly references firm's specific clauses | DELIGHT | 3s |

**Critical UX moments:**
- Training time estimate must come from actual hardware benchmark + model size, not a static formula (GAP-12: current plan says "6-8 hours"; correct estimate for 70B QLoRA is 12-20 hours)
- Live loss curve visualization in dashboard (can't wait 14 hours without feedback)
- Checkpoint save every 30 minutes (if training crashes at hour 12, don't lose everything)
- Export to GGUF: the LoRA adapter must be exportable as a GGUF-compatible format for llmhosts_core to load

---

## Advisory Panel: Friction Points Cross-Journey Analysis

**ELENA's Top 5 UX Friction Points:**
1. **Model download size disclosure**: Must be shown BEFORE user commits. 42GB surprises are rage-quit triggers.
2. **Authentication step**: Browser open at install causes 15-20% drop-off. "Continue without account" for first 24h.
3. **Env var configuration for Cursor**: Must be one-click, not copy-paste.
4. **Marketplace cold start**: Operators lose faith before first booking. Intermediate signals required.
5. **Training time estimates**: Grossly inaccurate estimates destroy trust. Dynamic estimation from first 100 steps.

**AMARA's Top 3 Community Moments:**
1. **"GPU recognized" moment** (Step B2): This is shareable. Add a "Share your setup" button.
2. **"First token served" notification**: Celebratory push notification that makes operators post screenshots.
3. **"Savings milestone" notification**: "$100 saved" triggers social sharing. Build this.

**MARCUS's Acquisition Funnel Assessment:**
- Top of funnel: Reddit/HN → landing page → install (conversion: target 40% of landing visitors install)
- Mid funnel: install → first inference (conversion: target 75%)
- Bottom funnel: first inference → 30-day active (conversion: target 55%)
- Monetization: 30-day active → Pro upgrade (conversion: target 12% in first 90 days)

**YUKI's Latency North Stars:**
- TTFT (Time to First Token): <100ms local, <200ms via relay, <500ms marketplace
- Throughput: >150 tok/s on RTX 4090 for 7B, >45 tok/s for 70B
- Relay overhead: <50ms round-trip added latency vs direct
- Cache hit: <5ms for exact, <50ms for semantic

---

## Journey North Stars (One-Sentence Each)

1. **Dev Anya First 30min:** "pip install llmhosts && llmhosts up — 8 minutes later, Cursor is using my home GPU and OpenAI is getting $0 from me."
2. **Remote Access:** "I'm in a coffee shop and the response came from my RTX 4090 at home — I can see it in the dashboard."
3. **Operator First Booking:** "I woke up to a $4.50 notification — my GPU earned money overnight while I slept."
4. **Enterprise Fleet:** "I replaced $5,000/month in cloud API costs with 5 desktop PCs my team already owned."
5. **API Consumer:** "It's cheaper than OpenAI, faster than cloud, and I don't need to own any hardware."
6. **Fine-Tuning:** "My legal team's contract analysis model is fine-tuned on 5 years of our own contracts, running on our own hardware, costing us nothing per query."

---

*Advisory Council — Day 2 Session — 2026-03-10*
*Lead: Elena Marchetti (UX) | Contributors: all 12 advisors*
