Documents Change. Most Tools Don't Track That Well.

Engineering calculations get revised. Load cases change. Safety factors get updated. Client requirements shift mid-project. Anyone who has managed a technical document through multiple review cycles knows the anxiety of the question: is this the current version, and can I prove it?

Most tools handle this poorly. A Word document gets saved over. A shared spreadsheet accumulates "v2_FINAL_revised_USE THIS ONE" filenames. Google Docs has version history, but it's a flat log of the whole file — useful when something goes wrong, not useful as a living audit trail you'd show a reviewer.

GridDoc approaches this differently.

Block-Level History

GridDoc's revision history tracks changes at the block level, not the document level. Every table, formula block, text section, and chart has its own history. When you change the input values in your load calculation table, GridDoc records that specific block's previous state, the timestamp, and the user who made the change.

This matters in practice. When a reviewer asks "what were the original beam dimensions before we updated the section?", you don't have to scroll through an undifferentiated log of every keystroke in the document. You navigate to the relevant block and see exactly what it looked like at each point in time.

Rollback at Any Granularity

Because history is tracked per block, rollback is targeted. You can restore a single formula block to a previous state without affecting anything else in the document. Changed your mind about a formula modification three edits ago? Revert just that block. Everything else — your narrative text, your charts, your updated inputs — stays current.

This is different from document-level undo. Undo is a linear stack that collapses the moment you close the file. Revision history is a persistent, non-destructive log you can navigate at any time, even weeks later.

What Gets Recorded

Every revision entry captures:

• What changed — the full previous state of the block, not just a diff
• When it changed — timestamp to the second
• Who changed it — tied to the user account that made the edit

For formula blocks, GridDoc also records the calculated output at the time of the change — not just the formula text. That means you can look at a past revision and see what the formula produced, even if the inputs it referenced have since changed.

Why This Matters for Engineering Documents in Particular

Technical documents in regulated industries — civil, structural, mechanical, electrical — are often subject to review requirements where traceability is part of the deliverable, not an afterthought. Reviewers want to see that a calculation was produced with specific inputs, on a specific date, and that any subsequent changes were deliberate and logged.

GridDoc's audit trail is designed to support that. Every version is preserved. Nothing is silently overwritten. And because the calculation engine is live inside the document, the recorded output values are always tied directly to the formula that produced them — there is no separate spreadsheet to correlate against.

Using Revision History in Practice

A few workflows where this becomes particularly useful:

Multi-reviewer sign-off. When a document goes through multiple engineering reviewers, each round of revisions creates a timestamped record. You can see exactly what state the document was in when each reviewer approved it.

Client-driven changes. When a client updates a scope requirement midway through a project, you can document the before/after state of every affected block — which inputs changed, what the recalculated outputs became, and when it happened.

Internal QA. Before submitting a final deliverable, use the revision log to confirm that every intentional change made since the last review is accounted for, and that nothing changed unexpectedly.

The Principle Behind It

A document that changes is more useful than one that does not — but only if you can trust it. Revision history is what makes a live, formula-driven document trustworthy over time. You get the recalculation benefits of a spreadsheet and the auditability that engineering work actually demands.

That is the combination GridDoc is designed around.