JobMatcha admin manual

One place for everything you've asked "how do I…?" about. Live tools at the top, written guides below. All endpoints here are admin-gated — your account must have users.is_admin = 1.

Test users + login as them

List of users. The Test only filter shows the throwaway users the test suite creates (test_*, uitest_*, dbg* at @example.com). For any user you can:

• Reset password — set a known password, then log in via /login.html with their email + that password.
• Impersonate — sets your browser's session cookie to theirs. Open /app.html in the same tab and you're them. To switch back, log out and log in as yourself.
• Grant / Revoke premium — toggles the subscriptions row without going through Stripe. For local testing only.
• Delete — hard delete (refuses admins and yourself).

Regenerate Career Explorer reports

Rebuild stored premium reports in place from their saved answers — so testers see new report content (ventures, expanded recommendations, the tabbed visual report) without re-taking the quiz. Target a report share token or an email (or regenerate everything). A deterministic rebuild is instant and free; tick Use LLM prose to also re-polish the narrative (slower, uses tokens).

🧪 Review batch — seeded reports for read-throughs

Seeded test people (@seed.jobmatcha.test) with full LLM reports. Links open the complete report without any login — send the lot to Vicky. Reseed/extend via tools/seed_review_batch.py.

Activation codes — free licences for partners & early users

Mint codes that unlock full access (same as an A$49.95 annual-pass purchase; codes grant 12 months) with no payment. Give one single-use code per person, or one multi-use code per partner with max uses = their allocation. Users redeem at /pricing.html (they need a free account first). Disable a code any time — already-redeemed users keep access.

Database browser read-only

Browse the live SQLite tables. Read-only — modifications need an explicit endpoint (use the user tools above for safe edits). Sensitive columns (password_hash, stripe_*_id) are truncated.

Email (SMTP) setup

JobMatcha sends two kinds of email: verify-email links at registration and password-reset links. Both are currently disabled — AUTO_VERIFY_USERS=1 in .env short-circuits the verify step, and resets only log to uvicorn-*.err.log instead of sending.

Step 1 — pick your sender pattern (support@ vs noreply@)

All the setup steps below use Pattern A. To switch to B, just add SMTP_REPLY_TO after changing SMTP_FROM.

Step 2 — pick an SMTP provider

# SendGrid example
SMTP_HOST=smtp.sendgrid.net
SMTP_PORT=587
SMTP_USER=apikey
SMTP_PASSWORD=<your SendGrid API key>
SMTP_FROM=JobMatcha <[email protected]>
[email protected]

Step 3 — add to .env and restart

Edit C:\inetpub\vhosts\jobmatcha.ai\app\.env and add the SMTP_* lines from your chosen option. Then turn off auto-verify so registration actually requires email confirmation:

AUTO_VERIFY_USERS=0

Restart the API (elevated PowerShell):

& 'C:\inetpub\vhosts\jobmatcha.ai\app\restart-api.ps1'

Step 4 — test it

1. Register a fresh account at /register.html.
2. If you get the verification email — done. Reply to it from a different account → confirm it lands in your support inbox.
3. If no email arrives, tail the uvicorn err log:

   Get-Content 'C:\inetpub\vhosts\jobmatcha.ai\app\logs\uvicorn-*.err.log' -Tail 40

   Look for lines starting with [mailer]. SMTP send failed tells you the underlying error.

Common errors

• Connection refused / timed out — your provider's port is blocked (often port 25 from cloud hosts). Try 587 or 465.
• Authentication failed — wrong user/password. Gmail needs an app password, not your normal Google password.
• Relay denied — Plesk Mail requires SMTP_USER to be an actual mailbox on this server, and the From domain to match.
• Emails land in spam — set up SPF + DKIM + DMARC for jobmatcha.ai. Plesk has one-click toggles under Mail → Mail Server Settings → Outgoing Mail Control.

Stripe + premium subscriptions

Two ways to make a user premium:

Step 1 — get your Stripe test keys

1. Sign in to dashboard.stripe.com.
2. Toggle the Test mode switch (top right) so you don't charge real cards.
3. Go to Developers → API keys → copy the Secret key (starts with sk_test_...).

Step 2 — create a product + price

1. Products → Add product → name JobMatcha Premium.
2. Add a price: $10.00 monthly recurring (or whatever you charge). Click Add price.
3. Copy the Price ID (looks like price_1Nxyz...).
4. Optionally add a second price for annual — copy that ID too.

Step 3 — set up the webhook

Stripe needs to tell JobMatcha when a subscription starts/ends.

1. Developers → Webhooks → Add endpoint.
2. URL: https://jobmatcha.ai/api/stripe/webhook
3. Events to listen for:
   • checkout.session.completed
   • customer.subscription.updated
   • customer.subscription.deleted
4. Reveal the Signing secret (starts with whsec_...) — copy it.

Step 4 — add to .env and restart

STRIPE_SECRET_KEY=sk_test_xxxxxxxxxxxxxxxx
STRIPE_PRICE_ID_MONTHLY=price_1Nxyzxxxxx
STRIPE_PRICE_ID_ANNUAL=price_1Nabcxxxxx   # optional
STRIPE_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxx

Restart the API: & 'C:\inetpub\vhosts\jobmatcha.ai\app\restart-api.ps1'

Step 5 — test the upgrade flow

1. Log in as a non-premium user.
2. Trigger an upgrade prompt (try to add a 2nd resume) → click upgrade → you should land on a real Stripe Checkout page.
3. Use Stripe's test card: 4242 4242 4242 4242, any future expiry, any CVC, any postcode.
4. After paying, Stripe sends the webhook to /api/stripe/webhook → your subscriptions row flips to status='active' → you're premium.

Other test cards

• 4000 0000 0000 9995 — declined (insufficient funds)
• 4000 0025 0000 3155 — requires 3D Secure authentication
• Full list: stripe.com/docs/testing

Local webhook delivery (optional)

If you're developing on this server but want Stripe events without exposing it publicly, install the Stripe CLI and forward:

stripe login
stripe listen --forward-to https://jobmatcha.ai/api/stripe/webhook

Running the test suite

19 tests (13 API + 6 UI Playwright). All against loopback uvicorn (http://127.0.0.1:8765).

# Both suites
.\run_tests.ps1

# API only (~1s)
.\run_tests.ps1 api

# UI only (~6s with Chromium)
.\run_tests.ps1 ui

# Single test
python -m pytest webapp/tests/test_api_smoke.py::test_application_status_patch_round_trip -v

First time: pip install -r webapp/tests/requirements-test.txt. Chromium is already installed for PDF rendering. Full docs: webapp/tests/README.md.

If tests skip with "login rate-limited"

You burned the 60/15min login limit (probably from repeated runs). Two fixes:

• Wait 15 minutes.
• OR add $env:JM_DISABLE_RATELIMIT = '1' to start_uvicorn.ps1 and run restart-api.ps1 elevated.

Deploy & service ops

Deploy from dev to production

cd C:\Development\JobHunter\AI4EMPLOYMENT
.\deploy.ps1

Copies static → httpdocs\, Python → app\webapp\, restarts the JobMatchaAPI scheduled task, smoke-tests /health.

Restart the API (without deploying)

# Normal (no elevation needed if no orphan)
Stop-ScheduledTask -TaskName JobMatchaAPI
Start-ScheduledTask -TaskName JobMatchaAPI

# If port 8765 is held by an orphan (deploy will warn): elevated
& 'C:\inetpub\vhosts\jobmatcha.ai\app\restart-api.ps1'

Check the API is up

curl http://127.0.0.1:8765/health
# OR via the public URL (Cloudflare):
# Just open https://jobmatcha.ai/api/health in a browser.

Logs

Get-ChildItem 'C:\inetpub\vhosts\jobmatcha.ai\app\logs' | Sort-Object LastWriteTime -Desc | Select -First 4
Get-Content 'C:\inetpub\vhosts\jobmatcha.ai\app\logs\uvicorn-*.err.log' -Tail 60

Plan limits (editable JSON)

Free-plan caps live in a JSON file you can edit any time — no restart, no deploy. The file is in data/ so it's preserved across deploys.

Location: C:\inetpub\vhosts\jobmatcha.ai\app\webapp\data\config.json

Default contents (auto-created if missing):

{
  "free_track_limit": 3,
  "free_interview_limit_per_month": 1,
  "free_monthly_llm_actions": 5,
  "_help": "Edit this file then refresh — changes apply on the next request, no restart needed."
}

Changes are picked up on the next API request (file mtime is checked per call). If the JSON is malformed, the API falls back to defaults and logs a warning — it won't crash.

Find Me Jobs — multi-source aggregator

The 🔍 Find Me Jobs feature queries multiple AU job-data sources in parallel, dedupes, and AI-ranks the union against the user's resume. Every result keeps its original source and apply URL so the user always follows the link to the real apply page — JobMatcha never wraps or proxies applications.

How the search-term inference works FAQ

Q: Does the user have to type a search term?

A: No — but they can. If the search-terms field is left blank, the system makes one cheap Claude Haiku call to read the resume and extract 3-5 distinctive keywords (role title + key skills). The user can override this by typing their own search terms — useful for "I want to pivot from Software Engineer to Data Analyst, find me Data Analyst jobs" where their resume isn't the right signal.

Will inference blow out the API budget?

• Query-generation call: ~AUD $0.001 per click (1 Haiku call, ~500 tokens in, ~50 out). Negligible.
• If the user types their own terms, this call is skipped entirely — saves the LLM roundtrip.
• The expensive part is the batch-scoring step (Step 5 below) regardless of how the query was generated. That dominates cost at ~AUD $0.12-0.18 per click.

Total cost per "Find me jobs" click: ~AUD $0.13 - $0.20 regardless of inference vs override.

The pipeline (6 steps)

1. Pick resume — user picks which of their resumes to match against (or default).
2. Build search query — either the user's typed terms OR one Haiku call to infer from the resume. Resolves to 3-5 keywords + a location (default "Australia").
3. Fan out to sources — all configured sources queried in parallel. ACT RSS pulls the full feed; Workday pulls per-tenant CXS JSON; Adzuna does keyword search with what_or (any keyword matches).
4. Dedupe — by source-prefixed ID first, then by (title, company) pair to catch the same role syndicated across multiple feeds.
5. Cheap pre-rank — count how many resume keywords appear in each job description. Pure Python, no LLM. Per-source quotas guarantee diversity: max 20 from Adzuna + min 5 reserved each for ACT Gov + Workday so smaller feeds don't get crowded out.
6. AI batch score — ONE Haiku call evaluates all 30 jobs in a single prompt and returns [{idx, score, why}]. Anything above the user's min match % is returned, sorted desc.

Sources currently wired live

Adding a new Workday university tenant

Most AU universities run Workday. Add to webapp/data/config.json (hot-reloads, no restart):

"workday_tenants": [
  {"slug": "usyd",    "host": "wd105", "site": "USYD_EXTERNAL_CAREER_SITE", "label": "The University of Sydney"},
  {"slug": "mq",      "host": "wd3",   "site": "CareersatMQ",               "label": "Macquarie University"},
  {"slug": "unimelb", "host": "wd105", "site": "UoM_External_Career",       "label": "The University of Melbourne"},
  {"slug": "wsu",     "host": "wd3",   "site": "WSUCareers",                "label": "Western Sydney University"}
]

Find slug/host/site from any Workday URL: https://{slug}.{host}.myworkdayjobs.com/{site}. Test in browser first — paste the URL, confirm jobs load.

Sources researched — full inventory

Honest map of every AU career site we evaluated. Wired = working today. Adzuna-covered = duplicated by Adzuna's crawl, so wiring directly would be redundant. Partnership-needed = path forward exists but requires a real conversation with the platform.

Funding pitch summary: Tier 1 (wired) covers ~80% of AU public jobs legally. Tier 2 (NSW PSC + APSC partnerships) is the next 15%. Tier 3 (state portal scraping with permission) is the final 5%. The story: "JobMatcha is the only AU job-seeker tool that combines AI-tailored matching with legally-aggregated public + government feeds, with active partnership conversations underway."

The unified job-hunt pipeline

Find Me Jobs, Match Reports, Tailor and Applications are now wired into one flow. The user starts at 🔍 Find Me Jobs with a cheap broad scan and progressively deepens engagement as they identify the role worth pursuing.

🔍 Find Me Jobs         📊 Score Job         ✨ Tailor              📁 Application
─────────────────  →  ─────────────  →  ─────────────────  →  ─────────────
~AUD $0.001/job        ~AUD $0.10           ~AUD $0.05            $0
Haiku batch score      Sonnet full          Sonnet tailored       saved row
+ "why" 1-sentence     match report:        resume + cover        + cover letter
                       gaps,                + tailoring notes     + description copy
                       interview prep,                            + match-report ref
                       application
                       strategy

Each step is opt-in per row. A user can scan 20 jobs cheaply, run Score Job on the 3 most interesting, tailor the 1 they're going to apply to. No wasted LLM spend on jobs the user wouldn't have applied to anyway.

Why the two scores differ

The Find Me Jobs score (Haiku) and the full Score Job score (Sonnet) often disagree by 5-15 points. That's expected:

• Find Me Jobs uses Haiku in a single batched prompt where 20 job descriptions compete for attention. It's calibrated as a fast triage ("is this worth a closer look?").
• Score Job uses Sonnet with a single job description and full attention. It produces gaps, application strategy, and interview prep — and a more considered score.
• When the report side panel detects a previous Find score (via sessionStorage from the click-through), both numbers are shown side-by-side with a one-line explanation. The Score Job result is the considered opinion.

Job description truncation — Adzuna's free-tier gotcha

Adzuna's free tier truncates job descriptions at ~1500 chars (ends with "..."). Without intervention, this propagates through the whole chain — the Match Report uses the excerpt, and the Tailor uses the excerpt. The output is still useful but misses keywords the full posting asks for.

The fix: the Match Report side panel detects truncation and shows a yellow callout with a "✏ Paste full description" button. The user opens the original posting in another tab, copies the full description, pastes it in. The endpoint POST /me/match-reports/{folder}/jd overwrites the saved jd.txt. The Tailor flow reads it on click-through, so the update propagates downstream automatically — no re-analysis required. The Tailor page also shows a truncation warning so the user gets a second chance to upgrade before tailoring. Better still: install the 📋 Bookmarklet (below) to capture the full posting on the source site in one click.

The data lineage

Find Me Jobs row            Match Report folder          Tailored folder        applications.csv
────────────────────  →  ──────────────────────────  →  ───────────────────  →  ─────────────────
job.description           MATCH_REPORTS//      JOB_SPECIFIC_RESUMES/    user_id + folder
(truncated)                 ├ jd.txt    ← editable      /                + from_match_report
job.apply_url               ├ match_result.json         ├ resume_tailored.md       column links back
job.score (Haiku)           ├ match_report.md           ├ cover_letter_tailored
job.source/source_label     ├ match_report.pdf          ├ jd.txt
                            ↓                           ├ tailoring_notes.md
                  saved into match_history.csv          ├ _match_report.md (copy)
                  (user_id, folder, score, engine)      ↓
                                                  saved into applications.csv
                                                  (from_match_report = folder)

Any downstream tool can walk back the chain: an application row points at the match report folder it was tailored from; the match report folder points at the resume track used; the user owns all three via user_id.

Find Me Jobs — search history

Every search is persisted to a new job_searches table (most-recent 50 per user; older auto-trimmed). Two UI surfaces:

• Session cache — the most recent search payload is cached in browser sessionStorage. Navigate away from Find Me Jobs and back → results restore instantly with no API call. Lost on browser-close.
• "Past searches" dropdown — collapsible panel above the search form. Lists all 50 persisted searches with query, location, result count, source mix, and timestamp. Each row has a Reload button that re-renders the saved snapshot (no re-run, no LLM cost) and a 🗑 to delete from history.

The dropdown is also the per-user audit log — if a user complains "I had 12 matches yesterday and now I have 4", they can reload yesterday's search to compare.

Get your Adzuna credentials

1. Sign up at developer.adzuna.com.
2. Register an app → receive an app_id + app_key.
3. Paste both into .env; restart elevated; done.
4. Free tier: 250 calls/month, 1000/day. For production volume, contact Adzuna sales.

Get your API credentials

1. Sign up at developer.adzuna.com.
2. Register an app. You'll receive an app_id + app_key pair.
3. Note the free tier rate limits (Adzuna doesn't publish them — they vary by application). For production volume, contact their sales.

Add to .env

ADZUNA_APP_ID=your_app_id_here
ADZUNA_APP_KEY=your_app_key_here

Restart the API: & 'C:\inetpub\vhosts\jobmatcha.ai\app\restart-api.ps1' (elevated).

Cost per click (approx.)

• 1 Adzuna search call: free within their tier; check live limits on dashboard
• 1 Claude Haiku 4.5 call to extract search query: ~AUD $0.001
• 1 Claude Haiku 4.5 call to batch-score top 20 jobs: ~AUD $0.08-0.15 (scales with resume length)
• Total: ~AUD $0.10-0.15 per "Find me jobs" click

How the pipeline works

1. Haiku reads the user's resume → returns a short search query (role + skills).
2. Adzuna search hits up to 50 fresh AU job ads matching that query.
3. Cheap keyword-overlap pre-filter cuts to the top 20 candidates.
4. Haiku scores those 20 in a single batched call: { idx, score, why } per job.
5. Results above the user's min match % threshold are shown, ranked.

Each "Find me jobs" click counts as one match action against the user's free-tier monthly quota (free_monthly_llm_actions in config.json).

📋 Bookmarklet — capture full job descriptions in one click

End-users: the same drag-installable link is shown directly on the user app at /app.html#/jd-clipboard (sidebar → 📋 Capture a posting). This admin section is the reference doc.

The bookmarklet solves the truncated job description problem end-to-end. Adzuna's free tier caps job descriptions at ~1,500 characters, and server-side scraping (Seek, LinkedIn, Indeed) is blocked by Cloudflare ~30-40% of the time and is legally murky anyway. The bookmarklet runs in your browser on a page you're already viewing — so it's the user, not JobMatcha, doing the read. Zero ToS risk, zero scraping cost, and it works on every site including Cloudflare-protected ones.

How it works (one paragraph)

You drag the link below into your browser's bookmarks bar. When you're on any job posting page — Seek, LinkedIn, Indeed, a careers page, anywhere — click the bookmark. It extracts the visible text, packages it with the page title, source URL, and timestamp, writes that JSON to your clipboard, and opens JobMatcha at #/jd-clipboard. JobMatcha asks for clipboard permission, parses the payload, shows you a preview, and runs Score Job against your chosen resume — full posting, no truncation, no scraping.

Install — drag this to your bookmarks bar

Use it in 3 steps

1. Open a job posting in your browser — Seek, LinkedIn, Indeed, a company careers page, anywhere. Make sure the full description is visible on the page (some sites hide it behind a "Show more" button — click that first).
2. Click the Send to JobMatcha bookmark in your bookmarks bar. The page won't visibly change but you'll briefly see a new tab open to JobMatcha. (If a permission prompt appears, "Allow" — it needs to write the job description to your clipboard.)
3. In the new JobMatcha tab at #/jd-clipboard, click Read from clipboard. You'll see the captured title, company, and full job description text. Pick the resume you want to match against and hit Score Job. A new Match Report opens with gap analysis, interview questions, and a strategy — all from the full posting, not a truncated excerpt.

Why we built this (vs. the alternatives) FAQ

Troubleshooting

Privacy & data flow

• The bookmarklet runs entirely in your browser. The page you're on does not know you clicked it.
• The JSON payload (description text + title + URL + timestamp) goes to your clipboard only. Nothing is sent to a server during the capture step.
• The payload is sent to JobMatcha's API only when you click Score Job on the #/jd-clipboard page — same data flow as any other Score Job action.
• The clipboard JSON includes source_url (the page you captured from). It's stored on your match report so you can re-open the original posting later.

🎭 Mock-Interview AI Avatar — build guide

Step-by-step plan for replacing the existing 🎤 icon at the top of the Mock Interview page with an animated avatar that looks like an interviewer. Goes from "free + ships today" through to "polished + lip-synced". You don't need all four — pick the tier that fits your demo timeline and budget.

How the question mix already works live

Before the avatar, what's the conversation: the question generator (/me/interviews/{id}/questions, see webapp/api.py → _INTERVIEW_QUESTIONS_SYSTEM) calls Sonnet with the job description + the user's resume + the match-report gaps. It returns 5–8 questions across four flavours:

• General / opener ("Walk me through your background")
• Behavioural / STAR ("Tell me about a time you…") — biased toward situations the resume hints at
• Technical / domain — drawn from JD-listed skills (e.g. Python, SQL, project management, classroom management)
• JD-specific / gap-probing — targeting the resume gaps the match report flagged, so the user gets to rehearse the hardest questions an interviewer would ask

The avatar work below is presentation, not content. The questions don't change.

Tier 1 — Lottie animation + existing TTS Recommended start

Cost: AUD $0 · Build time: half a day · Looks like: a clean cartoon-ish animated character that idles, blinks, occasionally tilts head. Speech via browser TTS.

1. Browse lottiefiles.com. Search "interviewer", "avatar talking", "person at desk". Filter to Free. Download a .json file (Lottie JSON is small — usually 20–80 KB).
2. Drop it into webapp/static/avatars/interviewer.json.
3. Add the Lottie web player to app.html: <script src="https://cdn.jsdelivr.net/npm/[email protected]/build/player/lottie.min.js"></script>
4. In the interview page (around #iv-stage in app.html) replace the 🎤 emoji with a 200×200 <div id="iv-avatar"></div>. Mount with lottie.loadAnimation({ container, path: '/static/avatars/interviewer.json', loop: true, autoplay: true }).
5. Wire to TTS state: pause the lottie when TTS is silent, play when speaking. The existing _ivSpeak() in app.js has the start/end hooks you need — it already calls onDone after speech finishes.

Trade-off: no real lip-sync — the mouth moves to the animation loop, not to the syllables. Most demo audiences don't notice; close-up users will. Ship this first, upgrade later.

Tier 2 — Pre-recorded human video loops + TTS

Cost: AUD $0 if you record yourself, or ~$5 stock-footage one-off · Build time: half a day + recording · Looks like: a real human interviewer at a desk, blinking, looking around. Speech still via TTS so lip-sync is faked.

1. Record (or download) three 5-second clips:
   • idle.mp4 — interviewer looking at notes, occasional glance up
   • thinking.mp4 — slight nod, eyebrow raise (plays during your answer)
   • speaking.mp4 — talking, looking at camera (plays while TTS reads the question — looks vaguely lip-synced because mouth moves)
   Free stock-footage sources: Pexels, Pixabay (Pexels licence is broad; Pixabay is permissive for commercial use).
2. Save them under webapp/static/avatars/.
3. Add a <video> element with autoplay muted loop playsinline. JS swaps src between the three clips based on interview state (asking question / waiting for answer / processing).

Trade-off: looks dramatically more human than Lottie but the seam between clips is visible on slower devices. Pre-load all three with video.preload="auto".

Tier 3 — Pre-rendered HeyGen / D-ID question bank

Cost: AUD $80–150 one-off (50 generic questions × ~$2 each) · Build time: 2–3 days (build + curation) · Looks like: polished avatar with real lip-sync on a curated set of questions.

1. Sign up at HeyGen (free trial gives ~3 min, then ~USD $24/month for 15 min/month).
2. Pick an avatar (their stock library has neutral interviewers; or pay extra for a custom avatar trained from a photo of you).
3. Pre-generate 50 of the most common interview questions across the four flavours above. Save each as q_001.mp4, q_002.mp4, etc. with a JSON index mapping each video to its text.
4. At runtime, the LLM still generates per-user questions; for each question, do a cheap cosine-similarity match against the question-bank index (use OpenAI embeddings or the small Voyage-Lite model — ~$0.0001 per match). Play the closest pre-rendered video. Fall back to Tier 1/2 if no match scores above 0.75.

Trade-off: every demo-day question that matches the bank looks magical; out-of-bank questions revert to non-polished. Coverage feels uneven. Best as a hybrid with Tier 1.

Tier 4 — Live HeyGen / D-ID API at session-time

Cost: ~AUD $0.30–1.00 per minute of generated video (D-ID is cheaper; HeyGen is glossier) · Build time: 1 day for API integration, ongoing maintenance · Looks like: indistinguishable from a Zoom call with a real person.

1. Sign up at D-ID or use HeyGen's streaming API.
2. When the LLM generates a question, POST it to D-ID with { text, voice, avatar_id }. D-ID returns a streaming MP4 URL within 3–8s.
3. Browser plays the MP4 inline. Answer phase shows a held-frame from a separate "listening" clip.
4. Add a backend cache: same question text → re-use the same MP4 (saves money for repeat users).

Trade-off: real money per session. For a free-tier user doing 5 questions × ~20s each = 100s of video = ~AUD $0.50–1.50 per session. Sustainable only behind a paywall.

Recommended path forward

1. This week (demo prep): Tier 1 — Lottie. Half a day's work, looks intentional, costs nothing, ships now.
2. After demo (early users): Tier 2 — pre-recorded human loops. Free upgrade if you record yourself; or ~$5 stock-footage if you'd rather not.
3. When you have ~50 paying users: Tier 4 — live D-ID. Gate behind premium tier. The polish becomes a paywall feature.

Skip Tier 3 unless you find it ships faster than 4 in your context — the hybrid approach adds complexity and the out-of-bank fallback breaks the illusion.

Where the avatar lives in the codebase

Env vars & secrets reference

Single file: C:\inetpub\vhosts\jobmatcha.ai\app\.env. After editing, restart the API or the new values won't be picked up.