A Runbook for Documenting a Structural Firm's QA/QC

A firm-wide standard, here's our default load factor assumption for this building type, here's our standard format for a calc package, needs to exist independent of any single project. Notion's relational databases let you build that standard once and link individual project calc packages back to the standard version they followed, so you can tell at a glance which standard was in effect when a given project was stamped.

Slite holds a single firm-wide standard well, but the link to which projects used which version of it is harder to maintain without Notion's relational structure.

A QA/QC procedure that exists on paper but hasn't been reconfirmed against current code requirements or firm practice is a liability, not a safeguard. Slite's mandatory recheck cadence forces a reconfirmation on a schedule, which matters here specifically because a code cycle update can quietly invalidate an assumption baked into an unreviewed procedure.

Notion can hold the same procedure, but nothing in the platform itself will flag it as due for review when a relevant code updates, unless the firm builds and maintains that trigger itself.

A junior engineer asking which connection detail the firm typically uses for a given condition shouldn't have to interrupt a principal every time. Slite's Ask AI, grounded in verified standards and citing its source, gives that engineer a fast, defensible first answer, with a clear trail back to the current standard if a senior engineer wants to double-check the reasoning.

Notion's search surfaces every past project's calc package matching the keywords, current standard or superseded one, leaving a junior engineer to judge which reflects current firm practice.

Accountants and auditors, a reasonable proxy for the technical staff a firm competes to hire, earn a median $83,680 a year¹, and structural engineers command more, which makes every hour spent reconstructing a firm standard from memory instead of finding it documented a genuinely expensive redo. General and administrative overhead runs a median 15% of revenue-equivalent spend at comparable professional-services businesses², a line documentation debt quietly inflates.

A firm's operations or QA lead, median pay $105,770 elsewhere in the market³, is usually the one who discovers a documentation gap during a peer review, which is the worst possible time to discover it.

The firms that handle this well tie their standards review to actual code cycle updates, not an arbitrary calendar, and keep project calc packages explicitly versioned against the standard in effect when the project was stamped. That versioning matters if a project is ever revisited years later under a different code cycle, whether for a renovation, a dispute, or a routine records request from a client's new owner.

The same versioning habit pays off internally too: a principal reviewing a junior engineer's calc package can check it against the exact standard version that was current at the time, rather than against today's version, which avoids flagging a perfectly correct package as noncompliant simply because the firm's default has since evolved.

For a comparison against a third, heavier platform, see where Confluence fits against both.

Keep standards defensible across code cycles with this sequence:

1. Tag each firm standard with an effective date range so it's clear which version applied when a project was completed.
2. Link every project's calc package to the specific standard version in effect at the time it was finished.
3. Assign a senior engineer or principal with current code expertise to own updates whenever a code cycle changes.
4. Trigger each update from the code adoption date in your jurisdiction so it doesn't slip past the deadline that matters.
5. Keep a core QA/QC checklist consistent across project types and layer project-type additions on top of it.

The most common failure mode isn't missing documentation, it's a firm standard that was updated in one senior engineer's head but never propagated to the written version. A principal decides mid-project that the firm's default approach to a particular connection type needs to change, applies the new approach going forward, and mentions it to a few colleagues, but the written standard still describes the old approach for months or years afterward.

A junior engineer who follows the written standard in good faith ends up producing work that doesn't match current firm practice, and nobody catches it until a review, if then. The fix isn't more documentation, it's a firm habit: any change to a standard gets written down the same day it's decided, before it's applied to a single project, not after it's already become informal common knowledge.

Firms that build this habit find their written standards actually track reality. Firms that don't end up with a standards library that looks complete and isn't trustworthy, which is arguably worse than having no written standards at all, since it creates false confidence.