Shipping a static calculator on a free domain: what actually took time
I built a small static site that converts Digital SAT practice-test raw scores into estimated scaled scores. One HTML page per question, no framework, no build step, no backend. The interesting part was not the code — it was everything around it: the domain, the DNS, the TLS, the search console, and the fact that a "score calculator" is an estimation problem disguised as arithmetic.
Notes on what cost time and what did not, in case you are shipping something similar.
The stack, deliberately boring
- Static HTML generated by a script, one file per page.
- Hosted on GitHub Pages, deployed by committing to
main. - Free domain from a registrar that gives out
dpdns.orgsubdomains, pointed at Cloudflare for DNS. - No analytics beyond the search console, no cookies, no JS framework. The calculator itself is a few hundred lines of vanilla JS.
Total monthly cost: zero. Total moving parts: three, and two of them are DNS.
Free domain plus Cloudflare: the parts that bite
The registrar flow is fine right up to one detail. When you point a domain at external nameservers through their API, the request needs the CSRF token that lives in your cookie, passed as a header. Without it you get a generic failure and no clue why.
Cloudflare has a related trap. Creating a zone through the API does not finish the job — the zone stays in initializing until you walk through the plan selection in the dashboard, even for the free plan. If you skip that step, DNS records you add will sit there inert and the domain will resolve to nothing. The fix is one dashboard visit: pick the free plan, decline the upsell, click "I have updated my nameservers". Then it goes active in about a minute.
Two records do the work:
A/CNAME @ -> <user>.github.io (DNS only, not proxied)
CNAME www -> your-domain
TXT @ -> search console verification string
Keep the apex record DNS only on the first pass. Proxying through Cloudflare before GitHub has issued the certificate leads to redirect loops that are annoying to diagnose, because both ends think the other one should be terminating TLS.
GitHub Pages TLS: wait, then wait properly
Adding a custom domain in the Pages settings writes a CNAME file into the repo and kicks off Let's Encrypt issuance. It takes about ten minutes and the UI shows three checkmarks as it progresses. Two things worth knowing:
- The "Enforce HTTPS" checkbox does not respond to a synthetic click in some automation setups. If you are scripting it, fire the click from the page context rather than dispatching mouse events.
- Until the certificate is issued,
https://on the custom domain fails whilehttp://works. That is normal, and it is not a DNS problem, so do not start debugging DNS.
Once it is issued, the old <user>.github.io URLs 301 to the custom domain automatically. No redirect configuration needed.
Verifying the domain without uploading a file
Search Console offers a domain property (DNS verification) and prefix properties (file, meta tag, or an existing Google Analytics tag). For a static site with no CMS, the DNS TXT route is the least fragile: you add one record, and it survives every redeploy.
Sitemap submission has one gotcha that wastes a day if you hit it: the sitemap field wants a full URL, not a path. sitemap.xml is rejected as invalid; https://example.com/sitemap.xml is accepted.
Requesting indexing is a separate step from submitting the sitemap, and the UI will not show you the request button unless you first navigate to the URL inspection page for that specific URL with the resource id in the query string. Two clicks per URL, and it only matters for the pages you actually want crawled early.
The actual engineering problem: there is no official conversion table
College Board publishes score ranges alongside practice tests, and an annual score distribution with a mean and standard deviation. It does not publish a raw-to-scaled conversion table for the Digital SAT. So any calculator has to reconstruct one, and the reconstruction has constraints that are worth stating openly rather than hiding behind a spinner:
- The test is adaptive between modules, so the conversion depends on which second module you were routed into. The same raw count can map to different scaled scores.
- Each module contains unscored pretest questions, so the scored pool is smaller than the question count.
- Forms are equated after each administration, which shifts the mapping slightly between test dates.
That means the honest output is a band, not a number. I fit a piecewise curve to the published ranges, sanity-check it against the annual distribution, and report the result with an explicit error bar of roughly 30 to 60 points. The UI says "estimate" everywhere, and the page explains why.
If you want to see the result: the calculator is at satcalcpro.dpdns.org, the method is written up under the scoring model notes, and the distribution work is in the percentile tables.
What I would skip next time
- The framework. A script that emits HTML beat every alternative, and the pages load in one request.
- Analytics before indexing. Ship the sitemap and the verification first. Traffic dashboards on an unindexed site are decoration.
-
Chasing links from sites that noindex their content. Paste services and anonymous note tools are plentiful, and a good number of them serve
noindexon exactly the pages you would use, which means the link does nothing for you. Check the page's meta robots before spending time on it.
What I would do again: the DNS-first setup, the one-file-per-page generation, and writing the estimation method down where a reader can check it. That last one is the only part that makes a calculator worth trusting.
Top comments (0)