Skip to content
Book a free call
Easify AI

Automating Engineering Calculation Checks Without Losing Sign-off

By Shaghil Shahzad, Easify AI · · 7 min read

Checking calculations is one of the most important jobs in an engineering team, and one of the most repetitive. A good share of a checker's time goes on confirming that units are consistent, that the loads match the drawing and that the right template was used, before the real engineering review starts.

Those mechanical checks can be automated. The judgement cannot, and the sign-off certainly cannot. This post sets out where the line sits and how to move the routine work to software without weakening your checking process.

Two kinds of check

Every calculation check mixes two kinds of work:

  • Mechanical checks: is the arithmetic right, do the inputs match the source, are the values within limits? These have one correct answer that can be found by following rules.
  • Engineering checks: is the method appropriate, are the assumptions reasonable, does the answer make sense for this structure, system or product? These depend on experience and context.

The first kind is where errors slip through when people are tired or rushed, because it is dull. The second kind is why you employ experienced checking engineers. Automating the first gives them more time for the second.

What to automate, and what to keep

Check Automate? Why
Unit consistency Yes Rule-based: every value carries a unit, and mismatches can be caught by script
Input values vs. drawing or spec Yes Values can be read from the drawing schedule or spec and compared line by line
Ranges and code limits Yes Limits from the codes and standards you use can be written down once and tested every time
Cross-references between calc sheets Yes A value carried from one sheet to another either matches or it doesn't
Spreadsheet or template version Yes The file can be compared with the current approved template in your register
Arithmetic re-run Yes An independent re-run in Python confirms the spreadsheet formulas give the stated results
Assumptions No Whether an assumption is reasonable depends on the project, the site and the client
Method choice No Choosing the right method is an engineering decision, not a rule
Engineering judgement No "Does this look right?" draws on experience no checklist captures
Final sign-off No The responsible engineer remains accountable for the calculation

Note: automation can still help with the bottom four rows by surfacing information, for example flagging a result that sits well outside similar past projects. It points the engineer at something worth a look. It does not decide.

The mechanical checks in more detail

Unit consistency. The most common mistakes are mixed units (kN and N, mm and m) and values typed without any unit at all. A script can read each input, check it has a unit and convert everything to a consistent base before comparing.

Inputs against the source. Loads, dimensions, material grades and design parameters should match the current drawing or specification. If those sources are structured (a schedule in Excel, a data sheet, a model export), the comparison is straightforward. If they are PDFs, a language model can read the values out, but those extracted values need checking more carefully than structured data.

Ranges and code limits. Many checks are of the form "this value must be below that limit". Write the limits your firm applies into a table, with the clause they come from, and test every relevant value against it on every run.

Cross-references. Large calculation packages pass values between sheets and between files. A broken link or a value copied by hand from an older revision is a classic source of error, and an easy one to detect.

Template version. If the calculation was built on last year's template, it may miss a correction you have since made. Checking the template version against your approved list takes seconds.

Arithmetic re-run. Re-running the calculation independently, in a short Python script, confirms that the spreadsheet formulas produce the results stated. It catches overwritten formulas and hard-coded numbers that look like calculated ones.

Watch out: a re-run in Python only proves the arithmetic matches. If the method in the spreadsheet is wrong, the script will faithfully reproduce the wrong answer. That is exactly why method review stays with the engineer.

How the process fits together

Automated checks sit between the designer finishing a calculation and the checking engineer starting their review. The checker receives the calculation together with a check report, and spends their time on what the report cannot cover.

  1. TriggerCalculation submitted

    Designer marks it ready to check

    Excel
  2. StepMechanical checks run

    Units, inputs, limits, versions

    Python
  3. AIUnusual results flagged

    Compared with similar past calcs

    Claude
  4. YouEngineer reviews and signs

    Assumptions, method, judgement

  5. ResultRecord filed

    Check report and sign-off kept

    SharePoint

If a mechanical check fails, the calculation goes back to the designer before it reaches the checker. That alone saves a round trip in many teams.

Keeping an audit trail

An automated check that leaves no record is worse than no check at all, because nobody can show later what was checked. For each run, keep:

  • What was checked: the file name, revision and template version.
  • Against what: the drawing number and revision, the spec reference, the version of the limits table.
  • The result of every check: pass, fail or not applicable, with the values compared.
  • Who reviewed and signed: the checking engineer's name, the date and any comments.
  • The version of the check script itself, so a result can be reproduced later.

Store the report alongside the calculation in your document management system, not in a separate tool nobody opens. When a client or auditor asks how a calculation was checked, the answer should take one click.

Tip: treat the check scripts and the limits table as controlled documents. Changes go through review and get a version number, just like a calculation template.

How to start

Don't try to automate checking across every calculation type at once. Start small and earn the checking engineers' trust.

  1. Pick one recurring calculation type. Choose one your team does often, with a stable template, such as a standard connection, a duct sizing or a beam check.
  2. Write the checklist down first. Ask the checking engineers what they actually check, in what order, and against which sources. If it isn't written down, it can't be automated.
  3. Split the list. Mark each item mechanical or engineering, using the table above as a guide.
  4. Automate the mechanical items. Build the checks against your existing spreadsheets and limits, and produce a short, readable report.
  5. Run in parallel with manual checks. For an agreed number of real calculations, the checker works as usual and also gets the report. Compare the findings each time.
  6. Reduce manual effort only when the results agree. Once the report reliably catches what the checker catches on the mechanical items, the checker can rely on it and focus on the engineering review.

During the parallel run, every disagreement is useful. Either the script missed something and needs fixing, or the manual check missed something and the script has just earned its place.

Example: a team starting with a standard calculation might find the first version of the report flags many false alarms, such as rounding differences. Agreeing tolerances with the checkers fixes most of them, and is a good conversation to have anyway.

Where this fits with your wider work

Calculation checking is one of several repetitive engineering tasks that can be handed to software while engineers keep control. Our guide to AI for engineering consultancies covers proposals, drawing registers and report drafting too, and Beaver is the engineering system we build on your own methods, with an engineer signing off every output.

If you are weighing up where to begin more broadly, why most AI implementations fail covers the usual traps, most of which come down to starting too big.

Summary

  • Automate the mechanical checks: units, inputs against sources, code limits, cross-references, template versions and arithmetic.
  • Keep the engineering checks human: assumptions, method choice and judgement stay with the checking engineer.
  • Sign-off does not move: the responsible engineer remains accountable for every calculation.
  • Record everything: what was checked, against which source, the results and who signed.
  • Start with one calculation type and run in parallel with manual checks until the results agree.

Frequently asked questions

Can software sign off an engineering calculation?
No. Software can run checks and report what it found, but the responsible engineer signs the calculation and remains accountable for it. Automation changes how the checking time is spent, not who carries responsibility.
Which calculation checks are best to automate first?
The mechanical ones that happen on every calculation: unit consistency, inputs compared with the drawing or specification, values against code limits, cross-references between sheets, the template version and a re-run of the arithmetic.
Do we need to replace our calculation spreadsheets?
Usually not. The checks can read your existing spreadsheets and templates. The method stays yours; the automation only checks how it has been applied.
How long should automated checks run alongside manual ones?
Long enough for the checking engineers to trust the results, typically a set number of real calculations agreed in advance. Compare both sets of findings each time and only reduce manual checking once they consistently agree.