The module map, photographed alive

A box-and-arrow diagram of a "reusable foundation" is the cheapest thing in software to produce and the easiest to fake. Every studio has one. Boxes labelled auth, email, billing; arrows between them; a confident caption. It costs an hour in a drawing tool and commits the author to nothing, because a diagram is a picture of an intention, and an intention is not a system.

So the only honest response to one is suspicion: is there something running underneath this, or is the picture the whole of it? That's a fair question to put to this site too, which leads with exactly such a map. The answer isn't an argument. It's three ways to check, arranged so each is harder to stage than the one before it — and the last one you can run yourself, right now, without taking anything here on trust.

First: the diagram has a photograph next to it

Beside the module map on the Foundation Map sits a screenshot, and it's a specific one: the admin's logging page, filtered to startup heartbeats, one row per service. Twelve services across two products — backends, modules, and both products' frontends — each announcing itself as it boots, on one page, each tagged in its own colour.

That screenshot is one of the diagram's arrows — the "everything reports to logging" edge — photographed instead of drawn. It is weaker proof than a live system and stronger proof than the diagram alone: a screenshot can be staged, but it's a picture of a running admin doing a real thing, not a shape in a slide. It moves the claim from this is how it would connect to this is the connection, mid-act.

Second: the same base carries two different products

A foundation earns the word only if more than one thing stands on it. One product on a "reusable" base proves nothing about reuse — the reuse is the claim, and a single instance can't test it.

The base behind this site runs under two live products that have nothing to do with each other. CompanyGraph is a stock-analysis platform with accounts and subscription billing — Stripe wired and live since before the first user. Smallbox Labs is the site you're reading. The same identity service signs users into both. The same email service queues and retries for both. The same logging and admin patterns answer "what happened" for both. It was built once and started on twice — which is the entire content of the word foundation, made checkable. You can describe reuse in a diagram; you can only demonstrate it with a second product, and the second product is here. It's the same proof that decides, from the hiring side, whether a base is something a developer can actually inherit — a thing that carries more than one product, or a thing that only describes one.

Third: the system shows its own pulse, live, to a stranger

The first two are pictures. The third is not.

There is a public status page that reads the fleet's heartbeats and recorded test runs straight off the logger, live, refreshing on its own. Not a screenshot of receipts — the receipts themselves, read server-side from the running system, that you can load this second. Each box reports that it booted; each suite reports the result of its last integration-test run against a real database. And the green counts aren't taken on faith either: each suite is checked by planting a real bug and confirming the test turns red, so a number on that board means a behaviour held, not that a test agreed with itself.

This is the one that can't be staged, because you're not looking at something I prepared — you're looking at the system describing itself, on a page open to anyone. A system that can show its own current state to a stranger is, by definition, one whose state doesn't live only in its author's head. That property is the whole of what operable means, and the status page is it, made public.

What the three prove, and what they don't

Notice the escalation, because it is the argument. A claim costs nothing. A screenshot costs a running admin. A live page anyone can load costs a system that genuinely reports its own state, continuously, whether or not anyone's watching. Each rung is harder to fake than the last, and at the top you no longer have to trust the author at all — you check.

What none of this proves is that the foundation fits your product. That's a real and separate question, and it's settled in a scoping conversation, not on a status page — some ideas don't need this base, and a few need something else first. What the three do prove is the narrower thing the diagram never could: the base is real, running, and operated, not a picture of an intention. If the diagram and the production system ever disagree, the rule is that production wins and the diagram gets fixed — which is the posture of a map drawn from a running system rather than the other way around. Start there, then check it against the live proof rather than taking the boxes on faith.