# Warren James · Technology Case Study Submission

**Candidate:** Reza Dawood
**Case study chosen:** New Launch / New Creator Auto-Spinup
**Local demo URL:** `http://localhost:8001`
**Stack:** Python · FastAPI · vanilla HTML/CSS/JS · Anthropic Claude API · stubbed external integrations

---

## 1. Starting With Why: The Business Goal

Before deciding which 4 of the 8 desired workflow pieces to automate, I started with the question: **what would actually move the needle for the business?**

The business goal is **maximizing the number of creators each pod can manage**. Today ~10 per pod, with a stated target of 3× over time. Most of the friction in getting there isn't in the creative work or the manufacturing. It's in the **pre-execution coordination time** between when a deal closes in HubSpot and when the launch is actually under way across all the systems and people that need to be aligned.

So I estimated the active human time per new-creator kickoff today, picked the 4 steps with the highest time savings (weighted by frequency and pipeline-blocking impact), and built them as one cascade.

### Estimated time per step today (active human work, not elapsed wait time)

> **Caveat (read first):** the per-step numbers below are my **best guesses pending actual discovery** with Drazen, Ben, and a Brand Manager. The only validated figure is the rough **150–200 hrs/launch end-to-end** range (which includes design, sourcing, sample rounds, manufacturing. Not just the pre-execution coordination this MVP touches). The order of magnitude of the table below is right, but **each row has ±50% uncertainty** until validated. A 30-minute working session with the people doing the work would tighten this.

| # | Spec piece | Active time per kickoff | Owner |
|---|---|---|---|
| 1 | Executive kickoff email (mostly copy-paste from BizDev doc) | 10–25 min | Drazen Jacinto |
| 2 | BizDev handoff doc (20+ sections) | 60–120 min | BizDev team + Ben |
| 3 | Pod assignment (work portion) | 15–30 min | Leadership |
| 4 | Kickoff team email | 15–30 min | BM / Drazen |
| 5 | Schedule kickoff call | 5–10 min | Drazen / Laura |
| 6 | Fathom recap → action items | 30–45 min | BM |
| 7 | Asana launch project from template | 30–45 min | BM |
| 8 | Kickoff / assortment deck starter | 60–120 min | DL |
| | **Total per kickoff** | **~225–425 min (≈ 3.75–7 hrs)** | Across 5+ people |

### The 4 I picked (and why)

| # | Spec piece | Status | Reason |
|---|---|---|---|
| 1 | Executive email | ✅ Built | High frequency + ~17 min/kickoff savings + pipeline-blocking (nothing else can fire until leadership knows). |
| 2 | BizDev handoff doc | ✅ Built | Highest single time savings (~90 min). Source-of-truth artifact that every downstream step feeds from. |
| 3 | Pod assignment + Sheet writeback | ✅ Built (spec-compliant + AI reasoning) | Modest active time (~22 min) but huge **elapsed time** compression. Pod decision currently sits idle for 1-3 days, blocking the cascade. |
| 7 | Asana launch project | ✅ Built | High precision (12+ custom fields, naming convention), high frequency (~5 launches/wk). |
| 6 | Fathom recap parse | ✅ Built as bonus | Maps to leadership's stated post-meeting workflow vision. The ~1.5 hr/day of admin time to reclaim. |

### Why I skipped or deferred the other 3

| # | Spec piece | Decision |
|---|---|---|
| 4 | Kickoff team email | **Skipped**. Largely overlapping with #1 (same template engine). Worth a 1-week extension; not in the MVP. |
| 5 | Schedule kickoff call | **Skipped**. Lowest time savings (~7 min). Real pain isn't scheduling, it's the meeting itself. |
| 8 | Kickoff / assortment deck | Tied for highest time savings (~90 min). **Deferred, not dismissed**. The right automation depends on inputs I don't have yet: how standardized are decks today? If most decks follow a consistent template (creator-specific text + imagery into known slots), this is a high-ROI build using vision extraction + Canva's Connect APIs (or the Canva ↔ Claude integration). If every deck is bespoke per creator with different layouts and sections, the value of automation drops sharply because the deck still needs human design work. **This is the piece I'm most interested to dive into together**. It's a meaningful chunk of time per kickoff and the answer comes from a 30-minute working session with the design lead, not from me guessing alone. |

**Net of my choices: ~2.8 hours of active human work saved per new-creator kickoff** (~52% of the full ~5.4-hour theoretical maximum).

### What this MVP delivers today (not what 3× would deliver)

I want to be careful about how this is framed. The 3× pod-capacity target is the **business's ultimate goal**, not what this MVP achieves. Computing savings against the 3× state would conflate the two. Here's the honest today's-state math:

| Scope | Calculation | Result |
|---|---|---|
| **Per pod, today** (10 creators × 3 drops/yr = 30 launches) | 2.8 hrs × 30 launches | **~84 hrs/yr saved per pod** |
| **Across ~6 pods** | 84 × 6 | **~504 hrs/yr** ≈ **0.25 FTE of recovered capacity** org-wide |
| **Conservative labor dollar value** ($50/hr loaded BM/DL time) | 504 × $50 | **~$25K/yr in labor savings** |
| **Plausible revenue throughput** (freed hours shipping as launches at an illustrative $400–500K GMV per account, at ~50% conversion) | 504 ÷ 175 × $400–500K × 50% | **~$575K–$720K/yr revenue** |
| **EBITDA contribution** (at an illustrative 10% EBITDA) | $575–720K × 10% | **~$58K–$72K/yr EBITDA** |
| **Valuation contribution** (at an illustrative 7× EBITDA multiple) | $58–72K × 7 | **~$400K–$505K valuation contribution** from this MVP alone |

### Why this matters more than the dollars look like

The 3× goal **isn't reachable by hiring 3× the BMs/DLs/PDs**. The cost would crush the unit economics. The only path is per-launch hour reduction. Math:

- 3× = 30 creators × 3 drops = **90 launches/pod/year**
- Current pod capacity = ~6,000 BM/DL/PD hours/yr
- At today's ~175 hrs/launch (the validated 150–200 hr range) → **15,750 hrs needed** for 90 launches, **2.6× over capacity**
- Therefore: 3× **mathematically requires** per-launch hours to drop from ~175 → ~67. That's a **62% reduction per launch**.

This MVP removes 2.8 of those 175 hours, **about 1.6% of the required reduction**. One brick in a wall that needs ~30 more bricks.

**But the asset isn't the hours saved. The asset is the pattern.** AI judgment layer + human approval gate + parallel cascade across existing systems is the shape that reapplies to:
- The Canva deck (spec #8). Same shape, +60–120 min/kickoff
- Creator engagement layer (1-click approvals via text). Same shape, +30–60 min/kickoff
- Post-launch attribution loop. Same shape, makes every future brief smarter
- AM copilot, marketing automation, asset pipeline

Each new automation built on this pattern is faster than the last because the plumbing exists. **That compounding is the 3× story**. Not any single MVP claim.

### What I'm NOT claiming

- ❌ This MVP delivers 3× pod capacity. It doesn't. It's ~2% of the per-launch hour reduction needed.
- ❌ The savings extrapolate linearly to $3M+ in revenue. They don't. Saved hours have to convert to actual launches, and that conversion rate is unproven until measured.
- ❌ "Hours saved × launches × GMV" is the right way to value this. It's not. That math assumes everything else stays constant, which the whole point of compounding automation is to disprove.

### What I AM claiming

- ✅ This MVP recovers ~2.8 hrs of active human work per new-creator kickoff today, sized against the validated 150–200 hr/launch range for the full arc.
- ✅ ~$25K/yr in immediate labor savings + plausible $575K–$720K/yr revenue throughput at an illustrative $400–500K GMV per account (at 50% conversion of freed hours to actual launches). At an illustrative 10% EBITDA and 7× EBITDA multiple, that's ~$400K–$505K of valuation contribution from this MVP alone.
- ✅ A reusable pattern (AI judgment + approval gate + cascade) that becomes the foundation for the next 5–10 automations. Each one compounds the previous one's leverage.
- ✅ A defensible step toward 3×, not a claim to have delivered it.

---

## 2. What I Built (technical summary)

A working prototype that fires when a creator moves to "Kickoff" in HubSpot and automates **4 downstream artifacts in parallel**, with one human approval gate in the middle. The artifacts are exactly what Drazen Jacinto (Creator Partner Assistant) and the brand team would otherwise build by hand.

**The 4 workflow pieces implemented end-to-end:**

1. **Executive kickoff email** (workflow piece #1), AI-drafted in Drazen's exact 7-section format
2. **BizDev handoff doc** (workflow piece #2), 20+ section Google Doc populated from creator data + AI-generated prose
3. **Pod-fit recommendation + Sheet writeback** (workflow piece #3, spec-compliant + AI reasoning), AI scores each pod with reasoning; leadership approves; Sheet row appends. Same human-in-the-loop the spec asked for, faster decision.
4. **Asana launch project from template** (workflow piece #7). Strict naming convention `[BRAND]_[COLLECTION]_[GZ/Domestic]`, 5 phase sections, 12+ custom fields

**Bonus:** Fathom recap parse → Asana action items (workflow piece #6). Wired but optional in the UI

---

## 2. Current-State Pain Points (As I Infer Them)

From the case study spec + the Lee Asher attachments (BizDev Handoff Questionnaire, Drazen's team-assignment email, Asana project screenshots, Cal invite):

- **Drazen writes the team-assignment email manually for every new creator.** The email has a tight 7-section format (Active flag, Content Style narrative, Socials, Sales benchmarks, Pending items, Creative pitch link, sign-off). Drazen does this by hand. Every creator, every time.
- **The BizDev Handoff Questionnaire** (20+ sections) is populated section-by-section by hand over hours, typically by the BizDev team coordinating with Ben.
- **Pod assignment** happens by leadership eyeballing the team-assignment email and deciding which BM has bandwidth. Pattern-match in their heads. Can take 1-3 days for the decision to land.
- **Asana launch project** is created from template manually (~30 min) and 12+ custom fields are populated per task by hand. At ~5 launches/week, that's ~2.5 hrs/week of repetitive setup.
- **The 17-person internal kickoff meeting** + Fathom recording produces action items that get manually copied into Asana afterward. Leadership has stated post-meeting admin runs ~1.5 hr/day. A chunk of time the team would rather get back.
- **The stated workflow vision** for that post-meeting time is for Fathom (their AI meeting-recap tool, also referenced in the case study spec) to auto-parse the recap and push action items into the system of record. The Fathom-recap-parse bonus arc in this MVP is exactly that pattern.

The pain isn't any single step. It's the **fragmentation**, 5 systems (HubSpot, Gmail, Google Docs, Google Sheets, Asana), 5+ people in the chain, no automation, no source-of-truth artifact that feeds them all.

---

## 3. Proposed Workflow for the MVP

```
[HubSpot: deal moves to Kickoff stage]
                │
                ▼
   ┌───────────────────────────┐
   │  Trigger received         │  (webhook → /api/trigger)
   │  Creator metadata loaded  │
   └────────────┬──────────────┘
                ▼
   ┌───────────────────────────┐
   │  AI Launch Brief          │  Claude Sonnet 4.5
   │  - Positioning            │  - Comp matching from creator metadata
   │  - Launch window          │  - Confidence scoring
   │  - Pricing tier           │  - Strict JSON output
   │  - Channel priority       │
   └────────────┬──────────────┘
                ▼
   ┌───────────────────────────┐
   │  HUMAN APPROVAL GATE      │  ← the only blocking step
   │  Review brief, approve    │
   └────────────┬──────────────┘
                ▼
   ┌─── Parallel cascade ──────────────────────────────┐
   │                                                    │
   │  ┌─────────────────────┐  ┌─────────────────────┐ │
   │  │ Executive email     │  │ BizDev handoff doc  │ │
   │  │ via Gmail API       │  │ via Google Docs API │ │
   │  └─────────────────────┘  └─────────────────────┘ │
   │  ┌─────────────────────┐  ┌─────────────────────┐ │
   │  │ Pod-fit recommend   │  │ Asana launch project│ │
   │  │ + Google Sheet write│  │ from template       │ │
   │  └─────────────────────┘  └─────────────────────┘ │
   └────────────────────────────────────────────────────┘
                │
                ▼
   ┌───────────────────────────────────────┐
   │  Bonus: Fathom recap → Asana tasks    │  (fires after kickoff call)
   │  via Fathom webhook + Claude parsing  │
   └───────────────────────────────────────┘
```

**Why these 4 of the 8 desired pieces:**

| Spec piece | Decision | Rationale |
|---|---|---|
| #1 Executive email | ✅ Built | Replaces Drazen's manual broadcast directly. Highest-frequency manual work. |
| #2 BizDev handoff doc | ✅ Built | The source-of-truth artifact every other step feeds from. Highest content density. |
| #3 Pod assignment | ✅ Built (spec-compliant + AI reasoning) | **Spec-compliant:** request goes to leadership in the email (step #1), Sheet writes on their approval. **Plus:** AI scores each pod with reasoning so leadership decides in 30 sec, not 1–3 days. See section 3.1 below. |
| #4 Kickoff team email | ❌ Skipped | Largely overlapping with #1. Once leadership confirms the pod, downstream comms can be pushed from the same template engine. Worth one more week of effort, not in the MVP. |
| #5 Schedule kickoff call | ❌ Skipped | Lowest leverage. Calendar invites take ~30 sec. Real pain is the meeting itself, not the scheduling. |
| #6 Fathom recap parse | ✅ Built (bonus) | Matches leadership's stated post-meeting workflow vision, Fathom auto-parses recap into action items, eliminating the ~1.5 hr/day of admin time the team wants to reclaim. Optional in the UI. |
| #7 Asana launch project | ✅ Built | High-frequency, high-precision (12+ custom fields). Naming convention matters. |
| #8 Canva deck starter | ⏸ Deferred (needs 30-min working session) | Tied for highest time savings (~90 min). Right approach depends on how standardized decks are today. Templated decks unlock vision-extract + Canva autofill; bespoke decks need a different shape. The piece I'm most interested to dive into together. |

### 3.1 Spec compliance on the pod assignment step (important)

The spec for piece #3 says: *"Request pod assignment from leadership and write responses back to a Google Sheet."*

My implementation:
- **The request goes to leadership**. Via the executive kickoff email (piece #1), which is sent to Saurabh + Kevin + Renee on the TO line (the pod-assignment decision-makers)
- **The Sheet write happens on their approval**. When leadership clicks Approve in the dashboard (or replies to the email), the pod-assignment row appends to the existing Team Assignment Google Sheet
- **The AI ranking is additive**. Leadership sees a scored recommendation with reasoning, but they still make the decision. They can approve the top pick or override

**Net effect:** I implemented exactly what the spec asked for (request to leadership → Sheet write on approval), and added AI scoring to compress the decision time from 1–3 days to ~30 seconds. The human-in-the-loop is preserved. The Sheet write is preserved. The improvement is in the quality of the request, not in skipping the spec.

If the evaluators specifically want the bare-minimum spec version without the AI scoring, it's a 5-minute change to remove the rankings UI and just present "approve this email goes" as the leadership prompt.

---

## 4. Architecture / Tooling Used

### Stack
- **Backend:** Python 3.11 + FastAPI + uvicorn (single-process, async-native)
- **Frontend:** Vanilla HTML/CSS/JS (no React, no build step, Tailwind not used, just hand-tuned CSS)
- **AI:** Anthropic Claude Sonnet 4.5 for the judgment layer (brief generation, email body, doc prose, pod-fit recommendation, Fathom recap parsing)
- **Data fixtures:** Lee Asher metadata (from the real BizDev Handoff doc + Drazen's email) + curated WJ team rosters (from Team List xlsx)
- **External integrations:** All stubbed. See below

### Stubbed integrations (ready for credentials)

Every external write is encapsulated in an API endpoint that returns the artifact it *would have* created, with explicit notes about what API + auth is needed for production:

| Integration | Endpoint | Production wiring |
|---|---|---|
| HubSpot trigger | `POST /api/trigger` | HubSpot Workflow → webhook POST to this URL with deal payload. Verify via `HUBSPOT_WEBHOOK_SECRET`. |
| Gmail (email)  | `POST /api/send-email` | Reuse the Google Workspace service account JSON. Replace stub `send_email()` with `googleapiclient.discovery.build('gmail', 'v1', credentials=...)` and `.users().messages().send(...)`. |
| Google Docs (handoff doc) | `POST /api/create-doc` | Service account JSON via `GOOGLE_SERVICE_ACCOUNT_JSON` env var. Use `googleapiclient.discovery.build('docs', 'v1')`. Copy from template, then batch-update sections. |
| Google Sheets (pod assignment) | `POST /api/recommend-pod` | Same service account. `googleapiclient.discovery.build('sheets', 'v4').append(...)`. |
| Asana (launch project) | `POST /api/create-project` | `ASANA_PERSONAL_ACCESS_TOKEN` env var. POST `/projects` with `template_id=1210851077487060`. PATCH custom fields. |
| Fathom (recap webhook) | `POST /api/parse-fathom` | Fathom webhook → this endpoint with the recap payload. AI parses; tasks post back to Asana via Asana token. |

### Why this stack

- **Python + FastAPI:** matches the existing UC-32 demo pattern (already in this codebase), so the team can extend either app with the same skills.
- **Vanilla frontend:** no npm install, no build step. The demo runs immediately after `uv sync`. Polished by hand-tuned CSS (~440 lines), not framework noise.
- **AI as judgment layer, not magic:** Claude is used for the 4 places where judgment matters (positioning, email tone, doc prose, pod fit). Everything else is plumbing.
- **Stubs return real-shape artifacts:** every stubbed step returns the actual JSON/text it would have created, so the UI shows the same artifact the human would review whether stubs are live or wired.

---

## 5. Risks / Limitations & What Needs Human Review

### What's stubbed and needs wiring before production
- **Gmail integration**. Body is AI-drafted but email isn't actually sent. ~15 minutes of service-account plumbing.
- **Google Docs / Sheets**. Doc content is generated but no real Google Doc is created. Service account + Docs API auth = ~30 min.
- **Asana**. Project structure is computed but no real Asana project is created. ~10 min once token is in.
- **HubSpot webhook**. Currently simulated by a button. ~15 min to wire a real workflow.

### What needs human review every time (not just at MVP)
- **The AI launch brief**. Explicit approval gate before any cascade fires. This is intentional, not a limitation. The human controls the box; AI fills it in.
- **The pod-fit recommendation**. Leadership clicks Approve or Override. The Sheet write only happens after explicit confirmation.
- **The executive email body**. Although AI-drafted, the cascade approval gate covers it. In production, an additional "preview before send" toggle would be reasonable.
- **The handoff doc**. Created automatically with placeholders for what's still pending (audience survey, creative questionnaire). Brand team fills in as data lands.

### Limitations honestly called out
- **The Lee Asher demo data is hand-curated**. In production, HubSpot would carry only what's actually in HubSpot (which is less rich than the BizDev handoff doc). The cascade would need to handle missing fields gracefully and prompt for them.
- **Pod data is curated, not pulled from a system**. In production, pod composition + load percentages should pull from a real team-management system (or a maintained Google Sheet, like the Team List xlsx).
- **The Canva creative pitch link is just a URL**. We don't validate that it loads or grab anything from it. (Computer-vision extraction would be a future-state feature; I've built this exact pattern at Miss Beauty for Canva flyer → site sync.)
- **No retries / no error handling for partial cascade failures**. If Gmail fails but Asana succeeds, the system doesn't currently roll back or alert. Addressed in the Phase 2 reliability layer (see §7).
- **No idempotency keys**. If HubSpot fires the same webhook twice (network retry), we'd create duplicate artifacts. Idempotency keyed on `deal_id` + `stage` is straightforward.
- **AI cost / rate limiting**. Not implemented for the demo. In production, per-trigger cost cap + monthly budget cap should be enforced (I've done this on Miss Beauty's chatbot in production).

### Assumptions I made
1. The HubSpot deal payload carries enough creator metadata to start the brief (creator name, archetype, audience size, content style narrative, past sales). If it doesn't, the team-assignment email is blocked on data, not on automation.
2. The leadership distribution list for the executive email is stable (Saurabh, Kevin, Renee on TO; Ben, Dylan, Laura on CC). Real team turnover would need a managed list.
3. Pod rosters are stable enough to recommend against. The Team List xlsx is the source.
4. The Asana launch template ID (`1210851077487060`) is the right template for ALL new-creator launches. If there are multiple templates per launch type, the brief should select.
5. The Google Doc handoff template ID is the right template. Same caveat.
6. The kickoff call still happens with a human in the loop (we're not automating the meeting itself, just the artifacts around it).

---

## 6. Success Metrics

### How "~3 hours saved per kickoff" is built

> **Same caveat as §1:** these per-step numbers are best-guess estimates pending discovery with the team that does the work. Order of magnitude is defensible; per-cell precision is ±50% until validated.

| Step | Today (manual) | Owner |
|---|---|---|
| Drazen drafts + sends executive email (mostly copy-paste from BizDev doc) | 10–25 min | Drazen Jacinto |
| BizDev handoff doc (20+ sections, populated by hand) | 60–120 min | BizDev team + Ben |
| Pod-assignment lead time (work portion, not elapsed) | 15–30 min | Leadership eyeball |
| Asana launch project setup (template + 12+ custom fields × tasks) | 30–45 min | Brand Manager |
| **Total work eliminated** | **~115–220 min (≈ 2–3.7 hrs)** | Mid-range ≈ 2.8 hrs |

*Not counted:* the elapsed waiting time (pod decision can sit for 1–3 days). Counting only active human work. Excludes Fathom-recap parsing (the leadership-flagged ~1.5 hr/day of admin) which is the Bonus arc.

### Outcomes

| Metric | Current state | After this MVP | After full build |
|---|---|---|---|
| **Active human time per new-creator kickoff** | ~115–220 min (≈ 2.8 hrs) | ~10 min (review brief, click approve) | <2 min (only exceptions reviewed) |
| **Elapsed time from Kickoff stage → Asana project live** | 1-3 days | <5 min | <1 min |
| **Drazen's email-drafting time** | 10–25 min per creator | ~0 (AI drafts; human approves cascade) | ~0 |
| **Pod assignment lead time** | 1-3 days (leadership eyeball) | Same day (recommendation arrives with email) | Same day, with AI score becoming training data |
| **Hours-back per launch** (toward 3× pod capacity goal) | n/a | ~2.8 hrs back | ~5 hrs back (if Fathom + creator-engagement layer added) |

**Tied to the 3× pod-capacity goal:** This MVP delivers ~2.8 hrs/launch back to the pod. That's ~10-15% of the full path to 3×. Worth doing because the savings compound (5 launches/week × 50 weeks = ~750 hrs/year just from this MVP, conservative).

---

## 6.5 An open architectural question worth discussing

This MVP is built as a **cascade across existing systems**, HubSpot triggers it, but the artifacts land in Gmail / Google Docs / Google Sheets / Asana, where teams already work. That's the cheap, pragmatic path.

The expensive question lurking underneath: **should WJ have a single internal operations hub**. One UI where leadership sees every in-flight launch, approves pod assignments, reads briefs, monitors drops? It would centralize what's currently bouncing across 5+ apps.

**Arguments for a hub:**
- One UI for leadership = no app-switching to approve a pod assignment
- Centralized log of every brief + decision + outcome → the AI training set compounds
- Cross-launch visibility across 70 stores in one place
- Per-creator P&L lives in one canonical view instead of being pulled from 5 sources

**Arguments against:**
- Another app to build and maintain. Another login, another set of permissions
- WJ teams already know Asana, HubSpot, Gmail. Retraining cost is real
- The integrations to feed the hub data are the same integrations you'd build for cascades. So build cascades first, hub later (if at all)
- The 2–3 person tech team can't sustain a custom UI long-term without trade-offs elsewhere

**My recommendation:** ship the cascade pattern first (cheap, immediate leverage), build a **lightweight admin dashboard** for monitoring (not full hub) within 3 months, and only commit to a full hub if the dashboard's usage patterns prove there's enough centralized work to justify it. **Don't build the hub on faith. Earn it with data from the cascades.**

---

## 7. What I'd Build Next (1 More Week)

In priority order:

1. **Wire the four stubbed integrations** (Gmail, Google Docs, Google Sheets, Asana — via the Workspace service account + Asana SDK). Each is ~30 min of API-key + boilerplate. Total: ~3 hours. After this, the cascade is fully live.
2. **HubSpot webhook signature verification + idempotency keys.** ~2 hours. Makes the trigger safe for real production.
3. **Per-trigger AI cost guardrail.** Cap total Claude spend per cascade so a runaway loop can't blow up a budget. ~1 hour. Pattern is the same as Miss Beauty chatbot rate limiting.
4. **Workflow piece #4 (kickoff team email)**. Once the pod recommendation is approved, fire a second email to the assigned BM/DL/PD with the brief + handoff doc + Asana project links. ~2 hours.
5. **Workflow piece #5 (calendar invite)**, Google Calendar API integration to auto-create the internal kickoff invite using the kickoff@warrenjames.org group alias. ~2 hours. Low priority but completes the picture.
6. **Workflow piece #8 (Canva deck starter)**. The answer depends on a 30-min working session with the design lead. If decks are templated: half-day build using vision extraction (same pattern I built at Miss Beauty for Canva flyer → site sync) + Canva Connect APIs / Canva-Claude integration to populate the template. If decks are bespoke per creator: a different solution shape. Probably AI-generated starter copy + asset suggestions into a blank deck for the designer to refine.
7. **Per-creator metadata enrichment**. When HubSpot data is thin, do a one-shot Claude call to enrich content style narrative from the creator's YouTube/Instagram public profile. Same pattern as Drazen does in his head today.

**Beyond 1 week (1-3 months at WJ):**

- **Creator engagement layer** (the biggest single lever toward 3× pod capacity), 1-click approvals via text, voice-memo parsing, structured-data ingest from creator-side communications. NOT shifting work to creators. Making whatever creators send work harder on the WJ side.
- **Cross-launch dashboard**. Single view of all in-flight launches with the AI-flagged risk items (ETA slips, missing approvals, blocked dependencies). Tied to Kevin's domain.
- **Post-launch attribution dashboard**. Pulls actuals from Shopify + Odoo + payout reports, ties them back to the original brief recommendations, builds the feedback loop that makes the next brief smarter.

---

## 8. Demo URLs + Access

**Local demo:** `http://localhost:8001`

To run:
```bash
cd wj-case-study-v2
uv sync  # or: pip install -e .
uv run uvicorn server.app:app --reload --port 8001
# Then open http://localhost:8001
```

**Without an Anthropic API key:** The app falls back to high-quality mock content (handcrafted for Lee Asher specifically). The cascade still runs end-to-end so you can see the flow.

**With an Anthropic API key:** Copy `.env.example` to `.env` and set `ANTHROPIC_API_KEY`. The app will pick it up. Claude will generate the brief, email body, doc prose, pod fit, and Fathom parse live.

**Loom walkthrough:** _(to be recorded)_

---

## 9. Closing Note

The case study spec says: *"The goal is not completeness. The goal is to show practical judgment, useful automation, and the ability to make something real quickly."*

What I tried to demonstrate:
- **Practical judgment**. Picked 4 of the 8 desired pieces based on highest-leverage (frequency × manual hours × downstream blocking). Skipped the 4 lower-leverage ones with explicit reasoning.
- **Useful automation**. Every step replaces real, named manual work (Drazen's email, the handoff doc, pod-assignment lead-time, BM's Asana setup, post-Fathom action items).
- **AI where it earns its place**. Judgment layer (brief, email tone, pod fit, recap parsing). Not in the plumbing.
- **Beat-the-ask where it costs nothing extra**. The pod recommendation upgrade is a strict improvement over the spec's Google Sheet write at the same human-in-the-loop cost.
- **Real artifacts, not screenshots**. The cascade produces actual JSON-shaped artifacts you can inspect. Swap the stubs for real APIs and the system goes live unchanged.

I'd love to walk through it together.