~/how-i-work

The invisible work you're actually paying for.

Anyone can show you a pretty homepage. This page is about everything underneath — the practices that decide whether your site still works in year three.

// every single change

Change → checks → preview → live.

This is a real merge gate from this site's own repository. Every project I run looks like this: the change is described, machines verify it, you preview it, and only then does it ship.

pull request — all checks required to merge

Lint, typecheck & test42s
Preview deploymentready
Dependency security scanclean
Preview link sent to client — awaiting a thumbs-up

// the standards

Six things you get without asking.

Nothing ships unchecked: Every change — mine included — goes through a pull request where automated checks run the linter, the type-checker, and the test suite. Red means it physically cannot merge. Your production site is protected from bad days.
You see it before the internet does: Every change gets its own private preview link. You click it, poke around on your phone, and say "yes" or "not quite" before anything touches the live site. No surprises on launch day.
I know about errors before you do: Production error monitoring with session replay: if something breaks for a real visitor, I get the alert, the stack trace, and a video-like replay of what they did. Most clients hear "found and fixed it" before they knew anything happened.
Typed end to end: From the database schema to the button on the page, the code is fully type-checked with zero escape hatches. A whole category of bugs — the "undefined is not a function" kind — is caught at build time, not by your customers.
Production-grade from day one: New projects start from a hardened template that already has the checks, the tests, the monitoring, and the security settings wired in. Your project inherits years of practice in its first commit.
Updates never stop: Dependencies get security patches weekly, reviewed and merged through the same gated pipeline. Sites I built years ago are still current — not quietly rotting.

~/fritz-automation/receipts.txt

// this very site, live — not marketing copy

$ sentry issues --unresolved --period 30d

monitored 24/7 — errors page me with a session replay

$grep -rn "as any" src/ | wc -l

$ git rev-parse --short HEAD

a7d81e9 — the exact commit serving you this page

→ These numbers are fetched from the real systems when this page is built. The site you're reading is the proof.

Want your project built like this?

Fifteen minutes, no prep, no pitch deck — bring the problem, I'll bring questions.

next build

$ compiling route

▮▮▮▮▮▮▮▮▮▮▮▮

// this usually takes no time at all

Change → checks → preview → live.

This is a real merge gate from this site's own repository. Every project I run looks like this: the change is described, machines verify it, you preview it, and only then does it ship.

pull request — all checks required to merge

Lint, typecheck & test42s
Preview deploymentready
Dependency security scanclean
Preview link sent to client — awaiting a thumbs-up

Six things you get without asking.

Nothing ships unchecked

Every change — mine included — goes through a pull request where automated checks run the linter, the type-checker, and the test suite. Red means it physically cannot merge. Your production site is protected from bad days.

You see it before the internet does

Every change gets its own private preview link. You click it, poke around on your phone, and say "yes" or "not quite" before anything touches the live site. No surprises on launch day.

I know about errors before you do

Production error monitoring with session replay: if something breaks for a real visitor, I get the alert, the stack trace, and a video-like replay of what they did. Most clients hear "found and fixed it" before they knew anything happened.

Typed end to end

From the database schema to the button on the page, the code is fully type-checked with zero escape hatches. A whole category of bugs — the "undefined is not a function" kind — is caught at build time, not by your customers.

Production-grade from day one

New projects start from a hardened template that already has the checks, the tests, the monitoring, and the security settings wired in. Your project inherits years of practice in its first commit.

Updates never stop

Dependencies get security patches weekly, reviewed and merged through the same gated pipeline. Sites I built years ago are still current — not quietly rotting.