The rule, in code

Florida bills split into two kinds of millage (dollars of tax per $1,000 of assessed value): school and non-school (county, city, special districts). Today a homestead gets two exemptions:

• $25,000 off the assessed value for all taxes;
• a second exemption, up to $25,722 for 2025 (indexed to inflation), on value between $50,000 and $75,000 — non-school taxes only.

Amendment 3 replaces both. Per the Property Appraisers' Association of Florida's FAQ, a homestead would get $25,000 off for school taxes (unchanged) and up to $150,000 in 2027, then $250,000 in 2028 off for non-school taxes, indexed from 2029.

def current_tax(value, school_mills, other_mills):
    first = min(value, 25_000)
    second = min(max(value - 50_000, 0), 25_722)
    return ((value - first) * school_mills
            + (value - first - second) * other_mills) / 1000

def amendment3_tax(value, school_mills, other_mills, non_school_exempt):
    school_taxable = value - min(value, 25_000)
    other_taxable = value - min(value, non_school_exempt)
    return (school_taxable * school_mills + other_taxable * other_mills) / 1000

Two things fall straight out of the code:

1. Savings are capped. Once the home is assessed at $250,000 or more, the extra exemption is fixed at about $199,278 of value ($250,000 minus today's $50,722). In dollars it can't exceed 199.278 × non-school mills, so it is the same for a $300,000 home and a $3 million one.
2. School taxes become most of the bill. In the median county, school millage makes up about 87% of what a median-value homestead would still owe in 2028.

The data

The Florida Department of Revenue publishes each county's 2025 millage: school operating, school debt, county, municipal and special district averages. Splitting school from everything else:

import pandas as pd

fl = pd.read_csv("florida_millage_2025.csv")
fl["school"] = fl["school_operating"] + fl["school_debt"]
fl["other"] = fl["total_mills"] - fl["school"]

For a "typical" home I used the Census ACS median value of owner-occupied homes in each county. That's a market value, not an assessed value, which matters (see below).

What it shows

At 2025 millage, for a homestead at the county's median home value:

Across all 67 counties:

• The median county saves about $1,559 a year in 2028, and $949 in 2027.
• In percent, cuts range from 17% to 67% of the bill (median 53%). The biggest percentage cuts are in cheaper counties; the biggest dollar savings are where non-school millage is high and homes are worth more than $250,000 (St. Lucie, about $3,041; Alachua, about $2,917).
• In 9 counties the median home is worth less than $150,000, so the 2027 exemption already covers it and the bill drops to school taxes only.

What the model leaves out

This is the part I'd want a reader to take seriously:

• Assessed value isn't market value. Save Our Homes caps a homestead's assessed value growth at 3% a year (or CPI). Someone who has owned since 2010 may be assessed at half the market value, so their dollar savings are smaller. The ACS medians overstate assessed value for long-time owners.
• Rates aren't fixed. The amendment changes taxable value, not millage. Because the taxable base shrinks, the "rolled-back rate" on 2027 TRIM notices effectively becomes a rolled-up rate, and each county, city and district sets its own millage in its budget. Holding 2025 rates constant is a lower bound on what local governments would need to change.
• New residents wait. People who become Florida residents on or after January 1, 2027 start with a $50,000 non-school exemption and get the larger one from their fifth year.
• County averages. The millage is a county-wide average including cities; a home in an unincorporated area or in a specific city will differ.

Try it

I put the model into a calculator with a county picker and the full 67-county table (sortable), so you can plug in the assessed value from your own TRIM notice: https://countypropertytaxes.com/florida-amendment-3-calculator/

The underlying CSVs (Florida millage, plus Texas and North Carolina rates and Census medians for every county) are CC BY 4.0 on Kaggle, Hugging Face and Zenodo if you want to run your own version.

Everything is generated from data

The site is Astro in fully static mode. A handful of Python scripts turn the sources (standards, spreadsheets, open-source libraries) into JSON in src/data/, and each JSON row becomes a page through getStaticPaths():

// src/pages/beams/[slug].astro
export function getStaticPaths() {
  return publishedOfKind("beam").map((section) => ({ params: { slug: section.slug }, props: { section } }));
}

The page then renders everything from that one row: weight in kg/m and lb/ft, a table of standard lengths, surface area for painting, the nearest equivalents in other standards, and an SVG cross-section drawn to scale from the dimensions. No images to maintain; change the data and every drawing follows.

The calculators are small TypeScript modules that Astro bundles into the page, sharing the same weight functions as the build (no UI framework on the client). Astro inlines the 4 KB stylesheet with build.inlineStylesheets: "always", so there is no render-blocking CSS request.

Hosting: Workers static assets, no Worker code

Cloudflare Workers can serve a directory of static files without any script:

// wrangler.jsonc
{
  "name": "steelweight-calculator",
  "compatibility_date": "2026-09-01",
  "assets": { "directory": "./dist", "not_found_handling": "404-page" },
  "workers_dev": false,
  "preview_urls": false
}

npm run build && wrangler deploy uploads only changed files. Two settings matter for SEO: workers_dev: false and preview_urls: false, so the site is not also served (and indexed) on a *.workers.dev address. The custom domain and the www → apex redirect are set up once in the dashboard.

With trailingSlash: "always" and build.format: "directory", every URL has exactly one form, which keeps canonical URLs, the sitemap and internal links consistent.

Release pages in batches

There are 222 section pages with real search demand, but a new domain publishing hundreds of near-identical pages on day one is asking to be ignored. So the build only renders the first N:

export const PUBLISHED = published.sections.slice(0, release.sections).map(findSection);

published.json lists the sections by search demand (from Keyword Planner exports), interleaving Indian, European and American sections so every batch covers all three markets. release.json holds N; raising it by 50 a week is the whole release process. Links on other pages use an isPublished() check so nothing points at a page that is not built yet, and a link checker over dist/ runs before every deploy.

Images without an image editor

Each page gets a 1200×630 social preview showing its key number ("ISMB 200 · 24.17 kg/m"), and the chart pages get a printable PDF. Both are made with Playwright after the build: a script walks dist/, pulls the <h1> and the answer line out of each page, fills an HTML template and takes a screenshot. The PDFs are the chart pages printed with a print stylesheet.

The same trick makes 1000×1500 Pinterest images: the page's drawing or the first rows of its table, trimmed in the browser until they fit:

for (;;) {
  more.textContent = hidden > 0 ? `+ ${hidden} more rows on the page` : "";
  if (main.scrollHeight <= main.clientHeight || rows.length <= 3) break;
  rows.pop().remove();
}

An RSS feed lists those images, and Pinterest turns each new feed item into a pin. Because each image keeps the date it was first generated, only pages from the new batch show up as new.

Data you can check

The part I spent the most time on was not the site but the data: recomputing derived columns (mass from area, radius of gyration from inertia) for every row found misprints in the standards themselves. I wrote that up separately, and the cleaned data is on GitHub as CSV/JSON: steel-section-weights.

Numbers so far

• About 180 pages built, 34 MB including images and PDFs, Lighthouse accessibility 100.
• Cost: the domain. Cloudflare's free plan covers the hosting, analytics and DNS.
• Deploy: one command, about 15 seconds of build and a few seconds of upload.

If you are building something similar (a calculator or reference site from structured data), the combination of a static generator, a data folder, and a scheduled release.json bump has been very low maintenance.

Transcribing tables is easy. Knowing the transcription (and the printed table) is right is the interesting part. Section tables have a nice property: their columns are not independent. A few physical relations tie them together, so every row can check itself.

The three relations

1. Mass follows from area. Steel is 7850 kg/m³. One metre of a section with area A cm² is A × 10⁻⁴ m³, so

mass (kg/m) = 0.785 × A (cm²)

2. Radius of gyration follows from inertia and area.

r = sqrt(I / A)

3. Elastic modulus follows from inertia and depth (for doubly symmetric beams, about the major axis):

Zx = Ix / (D / 2)

That is enough to check most columns of most rows. In Python, the core of it is a dozen lines:

import math

TOL = 0.02  # tables print 3 to 4 significant figures

def close(printed, derived, tol=TOL):
    # small values are printed to 0.1, so allow an absolute slack too
    return abs(printed - derived) <= tol * abs(derived) + 0.06

def check(row):
    problems = []
    if not close(row["M"], 0.785 * row["A"]):
        problems.append(("M", row["M"], round(0.785 * row["A"], 2)))
    for r, i in (("rx", "Ix"), ("ry", "Iy")):
        derived = math.sqrt(row[i] / row["A"])
        if not close(row[r], derived):
            problems.append((r, row[r], round(derived, 2)))
    if row.get("D") and not close(row["Zx"], row["Ix"] / (row["D"] / 20)):  # D in mm, Z in cm³
        problems.append(("Zx", row["Zx"], round(row["Ix"] / (row["D"] / 20), 1)))
    return problems

Run it over every row and anything it flags is either a transcription error (mine) or a misprint (theirs). I fixed mine; the rest went into an errata.csv next to the source data, so the source CSVs keep the printed value and the build applies the correction.

What it found

In IS 808:1989 (including its 1992 amendment):

In IS 808:2021:

The MC 175 one is my favourite: a mass that does not match its own area, carried from the 1989 table into the 2021 one, 32 years later.

Big tables from other places are not immune either. The AISC Shapes Database (the American reference spreadsheet) has its metric and US columns side by side; comparing them row by row found one cell, the perimeter of S24×90, with an extra zero (18400 mm instead of 1840).

The 1964 value everybody still uses

The relations also explained a long-standing confusion. Search for the weight of ISMB 200 and you get 25.4 kg/m from most charts and 24.2 kg/m from a few. Both are "right":

The 1989 revision thinned the flange. Charts copied from the old handbook never updated, so a 12 m beam is quoted 15 kg heavier than what is rolled today. The same happened to ISMB 100 (11.5 → 8.9 kg/m) and ISMB 300 (44.2 → 46.0 kg/m, heavier this time).

Takeaways for any engineering dataset

• Look for redundancy. Engineering tables usually contain derived columns. Recompute them instead of trusting them; disagreement is signal.
• Keep the printed value. Store corrections separately (errata.csv with the reason and the arithmetic) rather than editing the source, so anyone can audit the change.
• Check two sources against each other where they exist: two open libraries for European sections, metric vs US columns for AISC.
• Old editions matter. If users quote a number that does not match the current standard, the previous edition is often why — and showing both is more useful than silently picking one.

The cleaned tables are on GitHub as CSV/JSON: steel-section-weights. I also built them into a free reference site with a weight calculator and charts that show all three editions side by side: steelweight-calculator.com.