.jpg)
A structural engineer today works across a spreadsheet, a Python script, and an analysis model, sizing members, checking results, pulling geometry from a Revit model their drafters keep updated, and writing it all up in a calculation environment with AI tools. Then, to check any of it against the standard, they stop. They open a PDF, find the clause they , and re-key it by hand into a spreadsheet they built themselves.
The standard is the most authoritative reference in the room. It's also the only thing in that workflow that hasn't moved.
The gap is where the value leaks out
Every time a clause gets re-keyed into a private spreadsheet, three things happen, none of them good.
- The implementation becomes one more unmanaged version of the standard, slightly different from everyone else's.
- Errors creep in as these 'standards' aren't checked as rigorously.
- And the organisation that wrote the standard loses all visibility of how its own work is being applied.
Multiply that across an industry and you get the situation we have now: the standard is revered, and almost never used in the form its authors published. It lives on a shelf, while the real work happens somewhere it can't reach. (We've written before about the gap between a PDF and the workflow engineers actually need; standards are the sharpest version of that problem.)
"Digital" has to mean more than a machine-readable PDF
Standards bodies have seen this coming. Around the world they're moving toward digital and machine-readable formats, with the explicit goal of driving wider use and greater value from their standards. Standards Australia has been clear about that direction. The global push toward machine-readable, "smart" standards is the same impulse.
It's the right instinct, but machine-readable is necessary, not sufficient. A machine-readable standard that still sits outside the engineer's tools is a better-formatted document nobody reads in the moment of design. The format isn't the problem. The location and accessibility is.
From readable to runnable
Here's how we see it at CalcTree, and what we're building with the standards bodies we work with.
The shift that matters is from a standard you read to a standard you can run and integrate with programmatically.
A standard is, underneath the prose, a set of checks: equations, criteria, and the logic that defines correct application. Expressed as living logic rather than text, that standard can do something a PDF never could: interact directly with an engineer's actual work, or a company's internal review and QA automations. Not in a separate app they have to remember to open, but reaching into the model, the analysis file, the spreadsheet they're already in.
In practice, the approach is straightforward: the standard's logic is hosted once in CalcTree, connected to the engineer's analysis model and calculations, and run over the real geometry and loads, pulling geometry from the Revit model where it lives. It returns a result (what passes, what's flagged, and the transparent calculation behind it) as a traceable record, right where the engineer is already working. The standard comes to the work, not the other way around like it is today.
That's the difference between a standard that describes the work and one that reviews it.
What this unlocks for the arbitors of standards documentation
For a standards body, this isn't a tooling footnote. It changes the position of the standard itself.
It becomes present: used at the moment of design, every day, instead of consulted occasionally and re-typed badly. It becomes defensible: one authoritative, controlled implementation in place of a thousand private spreadsheets quietly drifting from intent. And it becomes the basis for new value: digital, usage-based and subscription models a static document was never able to support, and a first real window into how the standard is applied in the wild.
None of that requires the body to become a software company. It requires the standard to live where the work happens. (It also sidesteps a quieter problem we've covered, what actually happens when engineers paste standards into general-purpose AI tools, by giving the standard an authoritative digital home instead.)
Where we are with this
This is what we're building at CalcTree. We built a first version of it with Standards Australia, turning standards content into live, verifiable review logic as a proof of what a digital standard can be in practice, beyond a better PDF.
If you're a standards body or institution thinking about what digital should mean for your standards, we'd like to show you what it looks like to put one of yours into the workflow. Book a call →
.png)
