THE GATE CAME DOWN • NO ACCOUNT NEEDED TO SEE THE WORK • EXPERIMENTS LIVE IN THE LAB

don-the-imaginator.com: Why I Tore Down the Gate, Over-Built It, Then Chose Restraint

The first version of my portfolio made people create an account before they could see any work. My analytics (Firestore) told the story: about 10 visitors a month arrived from résumé links, 20% signed up, and 0% ever sent a first message. I took the gate down — then over-corrected: 5 switchable looks, an in-browser answer cache, a keep-alive script, all crammed onto one page. It proved I could build, and it overwhelmed anyone scanning fast. So V3 is restraint: a quiet editorial landing page for the 30-second scan, with the experiments — the theme engine, the graph tools, plain-English database queries — moved into /lab.

01 / DISCOVERY — THE SIGNUP WALL

The Wake-Up Call: 1 in 5 Signed Up, None Stayed

My analytics (Firestore: page views, accounts created, first chat messages) showed exactly where it broke. About 10 visitors a month arrived from résumé links. 20% created an account. 0% ever sent a first chat message. I had told myself a gate would feel exclusive; in a hiring review, a needless signup just kills interest. The sample is small — that is the honest size of it — but a funnel where nobody finishes is a funnel that is broken.

So I took V1 apart and listed what was wrong: 8 problems in 4 groups — the signup wall, ~30-second cold starts, a single beige look, and nothing to do after logging in.
What Was Wrong With V1 — and What I Did About It
8 Fixes
Hard-Coded Look → A Theme System
Styles became CSS variables, so the whole site can change its look without re-rendering
Keyword Badges → Real Case Studies
Vague skill tags replaced with full case studies and working tools
Signup Wall → Open Access
The gate came down. A small in-browser answer cache (Pocket-Synth) handles most simple questions in under 10ms, at $0
4-Step Survey → A 15-Second Tour
The role survey went; a short tour replaced it, with proof of work in under 5 seconds
Empty Screen After Login → A Story
The blank after-login screen became the story itself: V1 the gate → V2 the over-build → V3 restraint
Text Bubbles → Live Cards
Plain chat text became live, working cards (a valuation model, schedulers) built from a simple JSON format I defined
Scattered Thumbnails → 3 Deep Case Studies
A random grid became 3 deep studies, with the real code behind them
Showing Work → Building Systems
Real systems behind the site: Neo4j graph search, a Python valuation tool (~4ms), keep-alive scripts
02 / USER RESEARCH — TWO READERS I DESIGNED FOR (MODELS, NOT INTERVIEWS)

Two Ways People Read a Portfolio — the Insight That Created /lab

The quick scan (a model reader — call her Sarah, a VP of Applied AI; not a real interviewee): 30–60 seconds. Wants to see real work and try a tool within 5 seconds, with no account. Deal-breakers: a mandatory login, a 30-second cold start.

The deep read (a model reader — Marcus, a repeat founder; also not a real interviewee): 15–30 minutes. Wants the Python APIs, the Docker setup, how the Neo4j graph is queried, and whether the site stays up. Both readers are models I built from how hiring reviews actually work — I did not interview them, and I won’t pretend otherwise.

The conflict: one page was trying to serve both — theme pickers, a chat concierge, and dashboards all fighting for attention.

Decision: split the site. The landing page (/) is quiet and editorial, for the 30-second scan. /lab is the sandbox, where reviewers can try the tools, switch the looks, and see how the in-browser answers work.

THE SITE TODAY
/ — THE QUIET LANDING
Clean cream editorial page (#FAF9F6), Instrument Serif. No account needed to see the work. Direct links to the three case studies. In my 250-swap theme test, the layout did not shift.
V1: 20% SIGNED UP • 0% STAYED
/LAB — THE EXPERIMENTS
The playground: 5 switchable looks, the in-browser answer cache (40 of 50 test questions answered without calling an AI), live cards in chat, and a keep-alive script — temporary, running on my machine.
40/50 QUESTIONS ANSWERED IN-BROWSER • $0
Core Principles
1. Proof in under 5 seconds, no gate • 2. Simple questions answered in the browser; real tools behind them • 3. The keep-alive is a temporary local script → moving to Cloud Scheduler • 4. One theme system, used with restraint
03 / SYSTEMS — THE THEME ENGINE, KEPT IN /LAB

A Theme Engine With 5 Looks, Built on CSS Variables

To test how far a design system can stretch, I built a theme engine with 5 looks, using space-separated RGB values stored in root CSS variables (--theme-bg: 253 248 237). Tailwind maps via rgb(var(--theme-bg) / <alpha>).

Switching looks flips a single class on the root element, and the browser repaints at native speed. My test: 250 swaps on my machine — the layout did not shift (CLS 0) and a swap took ~16ms. That is a theme test, not a claim about every page; full checks across all 21 routes are still on my list.

Why this lives in /lab

General visitors need clarity, not a theme-switching demo. Keeping the experiment in /lab shows the discipline without distracting from the case studies.

THE THEME ENGINE & THE 5 LOOKS — TESTED WITH 250 SWAPS
Isolated in /lab
In-Browser Answers (Pocket-Synth)
In my test, 40 of 50 typical questions were answered right in the browser — no AI call, $0, under 10ms each. Test 2, 2,500 runs, on my machine.
LOCAL
The Backend: Graph Search + Tools That Do the Math
FastAPI + Neo4j + a Python tool (tools/dcf_tool.py) that values a company in ~4ms and cut the AI prompt from ~1,850 tokens to ~140. The AI only routes the question — the tools do the work.
PYTHON / FASTAPI
Plain-English Database Queries
Ask a question in plain English; it becomes a query over 45 MySQL tables (via FastAPI). Two layers of safety: the query is parsed (sqlglot) to allow exactly one read-only statement and block any changes, and the database account itself (nl_sql_reader) can only read. If a query fails, it gets one automatic retry with the error explained. Results appear as a live card (<NlSqlIntelligence />) with charts, tables, and CSV export.
READ-ONLY • SQLGLOT
LIVE CARDS IN CHAT (CUSTOM JSON, NO VERCEL SDK)
AI answers come back as a small JSON format I defined, and a typed parser turns them into live React cards inside the chat: <DcfModel />, <NlSqlIntelligence />, and more.
Neo-Brutalist
Swiss Grid
Terminal
Glassmorphism
Humanist
5 LOOKS • CSS VARIABLES • 250-SWAP TEST: NO LAYOUT SHIFT, ~16MS PER SWAP
don-the-imaginator.com • Reserved Landing • #FAF9F6 / #141413
Unified Editorial System
Tier 03 Pure Paper#FFFFFF
Tier 02 Paper Low#FAF2EC
Tier 01 Archival Canvas#FDFBF7
Typography Scale
Instrument Serif — Headlines
Newsreader — Body, JetBrains Mono — Telemetry
#141413 Ink#FF4D23 Signal#FAF9F6 Canvas
The Quiet Landing — Focused Simplicity
Don Martirez — Product Designer & Design Engineer
One voice across the suite: 3PM Daily (Python, several AI agents), Artstache (backed by a graph database), and this site (conversational). Same editorial system throughout. The two readers in §02 are models, not interviews.
/
The Deal: No Account Needed
Straight to the work and the code behind it. The in-browser cache answers most simple questions in under 10ms, for free.
The Fast Scan
Short summaries and direct links — proof within seconds, for the 30-second scan (the “Sarah” reader).
The Deep Read
The full sandbox in /lab: graph search, the valuation tool (~4ms), and plain-English database queries with the read-only safety check.
04 / IMPLEMENTATION — CHOOSING RESTRAINT

Choosing Restraint: One System Across All Three Projects

Why Restraint Matters
V2 proved the 5 looks worked — swapping them never shifted the layout. But a portfolio should not feel like a tech demo. The landing now uses one warm editorial look (#FAF9F6 / #141413 / #FF4D23) with Instrument Serif, Newsreader, and JetBrains Mono.
// How the site is split
/: quiet editorial, one look, no account needed, proof in under 5 seconds
/lab: the 5 looks, in-browser answers (40/50), valuation tool ~4ms
// Limitation: the keep-alive is a local script for now → Next: Cloud Scheduler
Design Outcome
The landing now matches Artstache and 3PM Daily, so the three projects read as one body of work instead of disconnected experiments. And the two reader types above are models I designed for — labeled as such, not passed off as interviews.
05 / KEEPING IT ALIVE — THE KEEP-ALIVE IS TEMPORARY

Keeping Free Databases Awake: A Local Script (for Now)

Free-tier databases fall asleep when they sit idle, and the first visitor after that can hit a ~30-second cold start — or an error page. For now, a PowerShell script on my own machine pings them to keep them warm. It only works while my machine is on. It is a workaround, not a solution.

The script has logged 1,420 warm-up cycles locally. The honest next step is Google Cloud Scheduler plus paid database tiers. I am not claiming 100% uptime, or that $0 a month is some permanent achievement — today’s setup is free tiers plus a script on my desk.

On layout stability: in the 250-swap theme test, the layout shift (CLS) measured 0 and a swap took ~16ms. Full Core Web Vitals across all 21 pages are still being checked — I will publish them when they are real numbers, not targets.

THEME TEST: NO LAYOUT SHIFT • ~16MS PER SWAPLOCAL KEEP-ALIVE (TEMP)NEXT: CLOUD SCHEDULER
KEEP-ALIVE MONITOR • LOGGED LOCALLY
THEME TEST: 250 SWAPS
Keep-Alive Config — Honest Status
{
  "database": "Neo4j AuraDB (Cloud)",
  "protocol": "neo4j+s / Bolt TLS",
  "current": "local keep-alive script (temp workaround)",
  "limitation": "requires dev machine on",
  "next": "GCP Cloud Scheduler + Aura Professional",
  "verified_warmup_cycles": 1420,
  "monitored_surfaces": ["/ (reserved)", "/lab (experimental)"],
  "infra_footprint": "serverless + free-tier + local daemon"
}
FCP
Goal: under 1s
Still checking
LCP
Goal: under 2.5s
21 pages
INP
Under 10ms, my machine
In-browser answers
CLS
0 shift / ~16ms
Theme test, 250 swaps
06 / OUTCOME — WHAT ACTUALLY CHANGED

Honest Outcomes: From a Signup Wall to an Open Site

1. The gate came down: The V1 numbers (Firestore): ~10 visitors a month, 20% signed up, 0% ever sent a message. Now there is no account between a visitor and the work, and the chat can be tried within seconds of landing.

2. The site split in two: Moving the 5 looks and the experiments into /lab kept the landing quiet. In testing, the in-browser cache answered 40 of 50 typical questions with no AI call and $0 cost (2,500 runs).

3. Tools do the work, the AI routes: The valuation tool answers in ~4ms typical (50 runs, my machine); a stock lookup ~10ms; weather ~23ms. Routing the question through tools instead of asking the AI to calculate cut the prompt from ~1,850 tokens to ~140.

4. Plain-English database queries: A small service turns questions into read-only queries over 45 tables. The database account can only read, the query is checked before it runs, and a failed query gets one automatic retry. Results stream into live cards with charts and CSV export.

5. The takeaway: Serve the visitor’s intent before asking for anything. Prove depth with systems people can actually try. And say the limitations out loud: the keep-alive is temporary, and the reader types are models, not interviews.

V1: ~10 VISITORS/MO • 20% SIGNED UP • 0% STAYEDIN-BROWSER ANSWERS: 40/50 • $0VALUATION TOOL ~4MSPLAIN-ENGLISH QUERIES • 45 TABLES • READ-ONLY
HOW IT CHANGED
V1: THE GATED RÉSUMÉ
About 10 visitors a month from résumé links; 20% made an account, 0% ever used the chat (Firestore analytics). A signup wall in front of the work.
V2: THE OVER-CORRECTION
5 switchable looks, in-browser answers, a keep-alive script. It proved real depth — and tired people out, all on one page.
V3: SPLIT IN TWO (CURRENT)
A quiet editorial landing for the fast scan + /lab, set apart, for the deep technical experiments. The 250-swap theme test showed no layout shift.
WHAT I LEARNED:
1. Remove needless friction → A funnel where 20% sign up and 0% stay is a broken funnel, whatever the sample size. Open access, proof in under 5 seconds.
2. Keep complexity in its own room → The 5 looks and the experiments live in /lab; the landing stays quiet.
3. Say the limitations out loud → The keep-alive runs on my machine, and only while it is on. Next: Cloud Scheduler. The reader types are models, labeled as such.