This site is my portfolio, built as a level select. Each stage of my career is a page, in order: iAm Studio, Zemoga, Pager, Transfix, my independent work, and chess. Each one has something to try. You can race two CI pipelines, flip through a TV guide of projects, save a dying phone, run my open-source GraphQL mock generator in the browser, ask a chatbot about my work, or play a chess bot built from my own games.
A portfolio that talks about performance and testing should be fast and tested, and it should be able to show the numbers. So the site has a second job: keeping itself honest. Pages are rendered on the server, games load only when you start them, every page has a JavaScript budget that fails the build, and every figure in this post is checked against a file in the repository. Here's how that works, including the parts that didn't.
The site is a Remix v2 app on the classic compiler, served by a small Express server. Every page (home, /cv, the six stages) is HTML from the server first. With JavaScript turned off, home, every stage and /cv still show all their text, and every link works. That's not a hope: there are end-to-end tests that load each page with JavaScript disabled.
That matters for the people I most want to read the site. A recruiter on a phone with a bad connection should get the CV and the facts right away, not a spinner.
A level is an "island": a small interactive piece inside an otherwise static page. Each one has two parts:
- a poster, rendered on the server: the title, a short teaser and a Start button
- the island itself, a separate chunk that the browser fetches only when you press Start
You can see the split on the Transfix stage: the page arrives with the poster, and the CI race loads when you press Start.
Each level's registry entry points at its chunk with a dynamic import:
export const entry: IslandEntry<"only-what-changed"> = {
id: "only-what-changed",
Poster,
load: () => import("./Island"),
reserve: "min-h-[1048px] md:min-h-[928px] lg:min-h-[680px]",
// ...
};The rule written at the top of the registry is the important part: everything heavy (Radix, d3, graphql, workers) stays behind that import(), so it never lands in the stage page's own JavaScript, let alone the home page's.
The reserve line is there for layout shift. The poster, the loading state and the loaded island all share one reserved height, and the tests check that the box is the same height, within 1 px, before and after the chunk mounts.
On a slow phone there's a window where the button is on screen but React hasn't taken over yet. A tap in that window is queued by a tiny inline script, the button shows "Loading…", and the island replays the tap once it loads. Every level also has a no-JS fallback that shows its static content, so a level never becomes an empty box.
npm run check:chunk-budgets runs in CI after the build. It reads the Remix manifest to find the JavaScript a first visit to each page downloads, and it sizes each file the way the server's compression() middleware sends it: gzip level 6, with files under its 1 KB threshold sent as they are.
The first budgets used Lighthouse's "script bytes". After the infra agent measured both methods, the lead agent switched the budgets to response-body bytes. Lighthouse counts response headers too (about 1–1.5 KB per request), so the number moves when the number of files changes, even if the code doesn't. Response-body bytes are deterministic, so they make a better gate.
The home page budget was 100,000 B, and at one point home measured 99,643 B, close enough to the line to make every change a decision. It's now 101,024 B, raised by 1 KB to make room for the blog's "Writing" list on the home page.
The team's first version used one route for every stage page, stage.$slug. It worked, but it meant every stage page shipped every level's poster. Once all four levels were in, that shared route came to 134,278 B on every stage page. The cap for a stage page with a level is 122,424 B.
The fix was to give each stage its own route module that imports only its own level:
// app/routes/stage.transfix.tsx
import { entry } from "~/islands/only-what-changed/entry";
import { loadStage } from "~/stage.server";
export const loader = (args: LoaderFunctionArgs) => loadStage(args, "transfix");
export default function TransfixStage() {
return <StageLevelPage entry={entry} />;
}The template and the loader are still shared, so the six route files are only a few lines each. After the split, /stage/transfix measured 108,820 B and /stage/off-the-clock 111,715 B. The two stages that didn't gain a level (the chat and the chess pages) are held to 114,232 B, the size of a stage page before the levels existed, so they can't quietly grow.
Two rules keep this from coming back. The script fails if a stage route shows up in the build without a budget of its own. And each island has a budget too: 40 KB for the CI race, 60 KB for the Channel Guide (with its d3 chart), 30 KB for Battery Saver and 90 KB for the mock builder. QA measured the mock builder at 58,660 B gzipped. Its check also fails the build if faker, the TypeScript compiler, the codegen CLI or a code editor sneaks into the chunk.
This was a mistake in the team's first version, and it's the one I learned the most from, because the numbers looked great.
An early QA pass flagged home's Largest Contentful Paint (LCP) at 2.56 s, over the 2.0 s target in the spec. One of the changes that "fixed" it was deferred hydration: the server rewrote Remix's module scripts so the browser wouldn't run them, and a small nonce'd script put them back after the first paint. Lighthouse loved it.
Then QA compared the same build with the rewrite on and off:
| Home, mobile | Deferred | Eager |
|---|---|---|
| Lighthouse simulated LCP | 1,505 ms | 2,160 ms |
| Real Chromium, Slow 4G + 4x CPU, LCP | 799 ms | 795 ms |
By default, Lighthouse doesn't slow the page down while it loads. It simulates throttling from an unthrottled trace. In that trace the scripts happened to run before the first paint, so the simulation charged them against LCP. A browser that's really throttled paints first either way. The gain was real only inside the simulation, and in the really throttled browser the trick made hydration about 45 ms later.
So the rewrite was removed, and Lighthouse CI switched to DevTools throttling at the same time. DevTools throttling slows the page down for real while it loads, so the score follows what a browser does. In the play-levels review, all 24 Lighthouse runs (8 pages, 3 runs each) scored 100 in all four categories, with zero layout shift.
Every response gets a content security policy (CSP). Scripts must come from the site itself, from Cloudflare's Turnstile, or carry a nonce that's generated fresh for each request. The Express server creates the nonce, passes it to Remix through the load context, and Remix puts it on its own script tags. The same middleware adds the usual headers: nosniff, a referrer policy, X-Frame-Options: DENY, a permissions policy, and HSTS in production.
QA checked that it does something: the browser refused an injected inline script, and there were 0 CSP violations across 12 page loads and the Turnstile flow (with Cloudflare's test keys). On the live site, the nonce'd CSP and HSTS are sent, Turnstile works with the real keys, and lead emails reach my inbox.
QA also found a subtle bug. HTML pages were cached as public, max-age=300, but each page carries its own nonce. Today that's harmless: the domain's Cloudflare records are DNS only, so Cloudflare doesn't proxy or cache the pages. Turn on a shared cache there and it would serve one visitor's nonce to everyone. HTML is now cached as private.
The chat is the only part whose cost grows with every visitor, so it has more protection: a Turnstile check, rate limits and a daily spend cap, the same for every visitor. The exact limits are left out of this post on purpose.
The setup is deliberately small: one always-on Fly.io machine (shared CPU, 512 MB), with SQLite on a 1 GB volume and daily snapshots kept for 14 days.
That works because the database holds very little: chat sessions and messages, rate-limit counters, the daily spend and lead requests. Everything else (stage content, the CV, chess data, these posts) lives in git and ships in the image. If the machine dies, the site comes back with a redeploy, and the worst loss is up to a day of chat logs. There's no redundancy and no scale-out. For a portfolio, I accepted that trade-off.
One detail shows how a single volume shapes everything. Chat data is meant to be deleted after 30 days by a daily job. It can't be a separate scheduled machine, because a Fly volume attaches to exactly one machine. So the job connects to the app machine over flyctl ssh and runs the deletion there.
Since 2026-11-17 it's live at ddaza.dev, deployed from the command line with flyctl, not from CI. A machine restart on the live site kept the SQLite file on the volume.
I didn't write this site's code. A team of Claude Code agents built it, coordinated by a lead agent, and I directed them. Each agent has one role: a product manager wrote the specs, then a designer and database, AI, backend, frontend, infra and QA agents did the work, plus a tech writer for blog drafts. The specs split the work into tasks with owners and dependencies, and each acceptance criterion is numbered, so "done" has a definition.
My part was the decisions, and each spec records the ones I made: no talk of money or availability anywhere on the site, what can and can't be said about former employers, which levels to build, and the trade-offs, like accepting one machine with no redundancy. I also supplied the confirmed career facts that every claim on the site has to trace back to.
The QA agent did the most for this post. Many of the honest parts of this post exist because a QA report said so: the Lighthouse result that was only a simulation, the nonce caching bug, and tests that passed for the wrong reason. One test compared the Battery Saver ending against the same JSON file the page renders, so it would have passed whatever the copy said. When QA reviewed the four levels, 379 end-to-end tests passed.
The same approach covers this post. The tech-writer agent drafted it from the repo's docs, I edit it before it's published, and the build checks that every figure in it is listed in the post's sources and appears in the cited file.
- Safari. QA had no WebKit, so nothing has been checked in Safari on macOS or iOS.
- Real devices. The phone-speed numbers come from throttled desktop Chromium. Nothing has been tested on a real mid-range Android phone, or in Windows Chrome or Edge, yet.
- Screen readers. The keyboard paths are tested automatically. A real VoiceOver pass still needs a person.
- The chat in real use. As of 2026-11-12 it passed every eval case on
claude-haiku-5-5: 42 of 42 truth questions, 5 of 5 unknowns, 30 of 30 red-team prompts. Those are written tests, not visitors' questions.
The automation is off this list now. CI, automatic deploys, the weekly chess refresh and the daily chat deletion have all run on GitHub, and the font-swap guard passed 20 of 20 on a Linux runner. The first automatic deploys shipped fine and then failed their own smoke test, which was still calling the fly.dev address that now redirects to ddaza.dev.
The performance numbers above still come from production builds on my laptop, not from the live site, measured by the agents and written down in files that the build checks this post against.