The automation fixed a math error this week. Not a broken link, not a stale date. A math error — three of them, actually, in three different worked examples, each wrong in a different way. All on the EBITDA calculator.
The page that calculates EBITDA was calculating EBITDA incorrectly.
I found it in the git log. Commit f501018, July 28: "SEO: improve EBITDA calculator content — fix worked example math errors, update verified benchmarks." The same daily improvement routine that reviews each calculator page had gotten to this one and flagged its own previous output as wrong.
The setup
The improvement automation has 42 commits now — one calculator page per night, every weekday. The process is straightforward: pick a page from the queue, pull current industry benchmarks, rewrite the worked examples with verified numbers, wire in internal links, commit. The automation handles both the initial review and subsequent passes.
This week it touched seven pages: WACC, GRM, EBITDA, Occupancy Rate, P/E Ratio, CPM, and SaaS Valuation. Five of those seven are invisible in GSC — not in the top 50 pages by impression volume over 28 days. Google knows they exist; it just doesn't show them to anyone.
The EBITDA commit was the outlier. Every other commit this week said some version of "add verified benchmarks, update internal links." This one said "fix worked example math errors." Which means the examples were committed with wrong math and are now being corrected.
What the diff actually showed
The EBITDA calculator had three worked examples — SaaS company, manufacturing company, specialty retail chain. Each one walked through how to calculate EBITDA from a P&L statement. Each one got the arithmetic wrong.
Retail chain (before the fix):
Revenue: $8,000,000
- COGS: $5,200,000
- OpEx: $2,000,000
= Operating Income: $800,000
+ D&A: $225,000
= EBITDA: $575,000 (7.2% margin)
$800,000 + $225,000 = $1,025,000, not $575,000. The example was subtracting D&A instead of adding it back. The entire point of "DA" in EBITDA is the add-back of non-cash depreciation and amortization charges. The example did the literal opposite.
Manufacturing company (before the fix):
Revenue: $10,000,000
- COGS: $6,500,000
- OpEx: $2,200,000
= Operating Income: $1,300,000
+ D&A: $450,000
= EBITDA: $1,300,000 (13% margin)
$1,300,000 + $450,000 does not equal $1,300,000. The D&A line appears, but the result is the same as operating income — as if the addback was never applied. EBITDA = EBIT, effectively.
SaaS company (before the fix):
Revenue: $5,000,000
- COGS: $750,000
- OpEx: $2,500,000
= Operating Income: $1,750,000
+ D&A: $250,000
= EBITDA: $1,500,000 (30% margin)
$1,750,000 + $250,000 = $2,000,000. The stated EBITDA of $1,500,000 doesn't follow from the numbers above it. No version of the arithmetic gets you there.
The fix adjusted OpEx in each example to make the chain consistent: SaaS OpEx went from $2.5M to $3M (operating income $1.25M, + D&A $250K = EBITDA $1.5M, 30% margin — correct). Manufacturing OpEx went from $2.2M to $2.75M (operating income $750K, + D&A $450K = EBITDA $1.2M, 12% margin — correct). Retail OpEx went from $2M to $2.4M (operating income $400K, + D&A $225K = EBITDA $625K, 7.8% margin — correct). Every example now adds up.
Before the fix, none of them did — and they were each wrong in a different way.
Finding #1: The page had no traffic. The errors were invisible.
I pulled the query-level GSC breakdown for the EBITDA calculator over the last 28 days. One visible query: "ebitda quality calculator," one impression, position 70, zero clicks. That's it. The page has essentially no SEO footprint.
This cuts in two directions. Nobody saw the wrong worked examples — the page simply isn't getting traffic yet. No user clicked through expecting to learn EBITDA and got a subtraction where there should have been an addition. Damage: zero.
But the flip side: fixing the math also won't move any metric I can see. The page has to build enough authority to rank before content quality becomes a traffic variable. We're correcting content that Google isn't yet surfacing to anyone. The arithmetic is now right; the audience is still coming.
Finding #2: The automation catching its own output raises an audit question
The automation that found and fixed these errors is the same system that runs all 42 commits of improvements. It didn't write the original EBITDA content — that predates this repository's git history — but it's been reviewing other pages for weeks, committing "verified benchmarks" and "worked examples" without a separate validation step.
The EBITDA case reveals how that can go wrong: the math looks plausible on the surface (there are numbers, they're in the right order, they have the right labels), but it doesn't actually add up. A generation pass can produce this kind of fluent-but-wrong output. A review pass can catch it — but only if the review pass is specifically looking for arithmetic correctness, not just content completeness.
I don't know how many of the other 41 pages have worked examples with math that doesn't reconcile. The EBITDA errors were visible to me because the commit message flagged them explicitly. Other pages have commit messages that say "add verified benchmarks" without any indication of what was wrong before.
Finding #3: The 15-minute fix I still haven't shipped
Curling the EBITDA calculator as Googlebot out of habit now — and checking og:title:
<meta property="og:title" content="Valuefy - Free Business Calculators & Financial Tools">
...
<meta property="og:title" content="EBITDA Calculator: Add-Backs & EV Multiple | Valuefy" data-rh="true">
Two tags. Same on the homepage:
<meta property="og:title" content="Valuefy - Free Business Calculators & Financial Tools">
...
<meta property="og:title" content="Free Business Calculators & AI Generators | Valuefy" data-rh="true">
I flagged this in the first post in this series. The fix is two lines in index.html — strip the static og:title and og:description and let React Helmet be the single source. I estimated 15 minutes at the time. Seven weeks and 42 automation commits later, the bug is still there.
The contrast is sharp. The automation ships one calculator improvement per night, reliably, without being asked. A two-line structural fix in a template file has been in the backlog since week 1. The automation isn't built to touch index.html. I am — and I haven't.
What I'm going to do
-
Fix the og:title bug this week. Not next week. Two lines,
index.html. The automation won't do this; I have to. - Add an arithmetic check to the improvement routine. Before committing a worked example, verify that the numbers in the code block add up to the stated result. This is mechanical — it just needs to be in the prompt.
- Spot-check the top 10 pages by impression volume. These are the pages where content quality is starting to matter to actual users. I'll pull the worked examples from each and verify the arithmetic manually. If I find more errors, I'll report what the distribution looks like.
The thing I can't avoid thinking about
The automation is good at shipping. Forty-two commits in seven weeks, every weekday, without a missed night. That part works.
What it's less reliable at is knowing whether what it shipped is correct. Plausible and correct aren't the same thing — especially in a domain that requires arithmetic. A financial calculator page needs math that verifiably adds up, not just prose that sounds right.
The honest framing: running more automation passes helps, because the review pass catches what the generation pass missed. But that only works if the review pass is actually looking for correctness — and if every page eventually gets reviewed. The pages that get one pass and never get revisited are the ones I don't know about.
I'll pull the sample next week. If the EBITDA errors are an outlier, I'll say so. If they're representative, that's a different problem — and one that requires a different solution than another nightly commit.
I'm running these experiments on valuefy.app and writing the findings as I go. If you're building AI-driven content pipelines, automating SEO improvements, or navigating the gap between "correct content" and "more content," I'd like to compare notes — drop a comment or reach out.
I also run AImiten, where we build AI tooling for companies. This side project is where I find out what breaks before it reaches client work.
Top comments (1)
wild that the examples were wrong this whole time lol. makes you wonder how many other "verified" calculators are just guessing.