Every change to the rules is a numbered version. Exactly one is current.
A project’s rulebook is one file: its tables, its fields, its formulas and its data. Each time it is saved, from the site, from the engine, from a folder on a laptop, the save is first registered: it gets the next version number and is kept, before anything else is decided. Then one question is asked: does this version become the current one? The answer follows four rules, and the small registry below follows the same four. Its fingerprints are computed in your browser with the same recipe the platform uses.
Registering v1…
What decides which version is current
- 1Registered first
A save gets its number and is stored before it is compiled or compared with anything. Whatever happens next, the work exists as a version.
- 2Made from the current version: it is current
This is the ordinary case, and the only thing most people ever see: “Saved as v6.”
- 3Made from an older version: merged, or held
If the two changed different things, they are merged and the merge is the next version. If they changed the same thing two ways, the later one is held as its own version, not current, until a person chooses. Nothing is written over.
- 4What does not compile is marked, not refused
It is saved, numbered and current like any other, marked “does not compile”. Someone who needs only the database may not care; anyone else steps back one version.
Going back is not a fifth rule. Any version can be made current again, one step back or forward at a time; that moves a pointer and writes no version, so it can be undone the same way.
A rulebook is not another kind of code
Rules written as code
A late-fee rule in an ordinary application is written several times: in the database, in the server, in the screens, in a spreadsheet someone keeps. A “version” is a commit across many files in several languages. Whether two running copies apply the same rule is something you work out by reading them, and whether a commit still builds is found out later, by running it.
Rules written as a rulebook
The rule is stated once, as data: a field with a formula, in one file. The database, the API, the spreadsheet and the plain-English description are generated from that file, so none of them can say something different. That is why “which rules are running?” has an exact answer here: a version number, and one fingerprint of one file. And because the whole file compiles or does not, “does not compile” is one mark on one version, not a hunt through a codebase.
You can see the generated copies move together on the live rulebook page: one rule, changed once, and Postgres, TypeScript, Excel and English rebuilt from it.
A git log can’t tell you which commits matter. A rulebook can.
Move a button, refactor a service, change how late fees are calculated — git gives every one of those commits a hash, the same way. An Effortless project is tracked in git too, but its rulebook gets a new hash only when a rule actually changes, with the exact line that changed named next to it: auditable, cradle to grave. Most software can’t offer that, because the rules and the implementation are mixed together across the whole codebase.
What a fingerprint proves, and what it does not
Each version has two fingerprints. The first is of its text alone: the same rulebook always has the same one, which is how any copy can be asked “which version are you?” The second covers the version’s number, its text, its date and the second fingerprint of the version before it. Change anything in an earlier version and every fingerprint after it stops matching. Software people call this a hash chain; it is the same idea git uses for its history.
It proves
That this exact text was version 19, registered at this moment, after exactly these eighteen versions. That no earlier version has been altered since. The database refuses any change to a registered version’s number, text, date or fingerprints, and the chain shows it if that refusal is ever bypassed.
It does not prove
That nobody rewrote the whole history at once: someone in full control of the database could recompute every fingerprint. So the evidence is only as strong as its witness outside the database. Here that witness is the project’s git repository, which receives each version that becomes current. It also records the order of versions, not the moment each one was made current; that is a date stored beside it.
These rules are themselves a rulebook
The platform keeps its own data in a rulebook. The versioning above is six of its fields; the two tables are ProjectFiles and ProjectFileVersions.
ProjectFiles.CurrentVersionNumberstoredThe pointer: the number of the version that is current. Everything else follows from it.ProjectFiles.NextVersionNumber= MaxVersionNumber + 1The number the next save gets. Registering is the first step of any change.ProjectFiles.CurrentRulebookHash= IF(LocalhostHash = BLANK(), ComputedHash, LocalhostHash)The fingerprint of the current rulebook. A rulebook kept on its owner's machine reports its own.ProjectFileVersions.IsCurrent= SequenceNumber = FileCurrentVersionNumberComputed, never stored: exactly one version is current, by construction.ProjectFileVersions.Compiles= IF(CompileStatus = "failed", FALSE(), TRUE())A version that does not compile can still be current; this marks it, so the list says so.ProjectFileVersions.VersionHashsha256(number, content, previous VersionHash, date)The version's link in the chain. Set once by the database when the version is registered; refused ever after.On your own project it is the Versions link on the Rulebook tab: every version by number, which one is current, why another is not, and a line saying whether the chain is intact. Open a project →