Cheap vs expensive: who pays

Every system has to spend effort somewhere — resolving references, building pages, checking permissions. The interesting question is never whether there’s a cost, but who pays it and when. CTXR makes a single, consistent choice: the editor pays, the visitor doesn’t.

The bargain

Editing is where the work happens. Creating, saving, and especially approving a node triggers real effort: the compiler resolves references, calculates derived values, and cascades the change to every document that depended on it. That’s the expensive moment — and it’s paid by one editor, once, at the moment they choose to publish.

Serving is where the work doesn’t happen. A visitor’s page view is close to free: look up the path, open one pre-compiled JSON file, render it. No queries, no joins, no reference resolution, no cache to warm. The expensive thinking already happened at approve time; the visitor just reads the result.

This is the whole point of the compiled graph. We move the cost from the hot path (millions of reads) to the cold path (occasional writes), because that’s where it does the least harm.

Tiers of cost

It helps to see who pays at each tier:

Who	When	Cost
Visitor	Every page view	One path lookup + one file read. Effectively free.
Editor	While editing a draft	Writes touch only the draft; the live site is untouched.
Editor	On approve	Compile + cascade. The expensive moment, paid deliberately.
First visitor past a limit	First request for a large related list	One query, then cached for everyone after.

The pattern is consistent: cost lands on the person taking the action, at the moment they take it, and never gets charged again to the people who merely look.

Limits as a technical guarantee

Because the expensive work is bounded to writes and cascades, the platform can put real numbers on it. Plans cap things like pages, collections and stored items — and those caps aren’t a sales lever dressed up as a feature. They’re the honest expression of what stays fast.

A cascade’s cost scales with how many places a node appears in. Related lists are paginated so the indexes that drive them stay bounded. Put those together and a space’s performance is predictable within its plan: the limits are the line beyond which the write-time bargain would stop paying off. We’d rather state that line plainly than let a space quietly degrade.

Where this leaves rich features

Some capabilities are genuinely expensive no matter when you run them — on-the-fly image resizing, machine translation, large AI generations. CTXR treats these as opt-in rather than baked in: the platform stays cheap by default, and a space turns on the costly machinery only when it needs it (usually through a connector). The default path is fast and free; the expensive path exists, clearly marked, for when it’s worth it.