VicroCode
Make Code Create Value
VicroCode is a lightweight online platform for publishing, running, sharing, and monetizing code projects. Launch HTML, Python, SQLite, AI agents, management tools, games, and more without server setup.
Please wait while VicroCode loads. You can also explore the AI programming guide
Loading...

AI MARKET GUIDE

Rebuilding the HN launch classifier as a hosted tool: viral spikes vs SEO builds, from public data only

A debrief on turning one v2ex experiment that scored HN launches by sitemap density into a small reusable tool: a Python scorer, a SQLite catalog you fix by hand, and one HTML board.

Someone on v2ex ran a small experiment this week that's worth stealing the structure of, not the conclusions. They took 12 new sites that showed up on Hacker News and tried to answer one question: did this site grow because search slowly found it, or because one post detonated on a social front page?

The method was deliberately cheap. Three free public endpoints, nothing paid. HN's Algolia API for the score, RDAP for the domain registration date, and the site's own sitemap.xml to count content pages. From those three numbers they derived a single ratio they called content-page density: sitemap pages divided by domain age in months.

The headline numbers, which I'm treating as the author's own figures and not a validated benchmark, were that the five highest-scoring launches averaged 184 points with essentially zero content pages, while the two sites doing serious SEO averaged 49 points but carried 500-plus pages each. The author is explicit about the limits: 12 samples, all from HN, all skewed technical and English, and it's inference about strategy, not measured traffic. It doesn't tell you how many visitors a site gets. It tells you whether the site has a second road besides the one hot day.

That caveat is the whole value, so keep it attached to every number you produce.

Why rebuild this instead of just reading about it?

A one-off post ages out. The underlying signal doesn't. If you're an indie builder deciding whether a trending launch is something you could realistically copy, "new domain, no sitemap, huge spike" is a useful warning: you can't plan to go viral on a Tuesday. A site with 100-plus pages and a domain older than three months has already survived cold start, which is the part most people skip.

So the thing worth owning isn't the article, it's the signal layer underneath it: a repeatable job that fetches the three inputs, scores a domain, and lets you correct it when the automated rule is obviously wrong. I'll walk through building exactly that scope on VicroCode, and I'll be honest about where the platform's edges are.

How does the Python scorer work?

The fetch-and-score step is plain Python. You pass a list of domains, and for each one you hit the Algolia search API for its HN story score, query RDAP for the registration date, and try to pull sitemap.xml to count URLs. Then you apply the author's rule set more or less verbatim: density above roughly 80 pages per month reads as SEO-driven; no sitemap plus a domain under a month old plus a high score reads as viral or social; low page count on an old domain reads as brand or word-of-mouth.

You can run Python online for this directly, which matters because all three endpoints are external HTTP calls and you want them to execute server-side rather than from a browser fighting CORS. Write defensively. Sitemaps go missing, return HTML error pages, or sit behind an index file that points at ten more sitemaps. RDAP responses vary by registry. Treat every field as possibly absent and record "unknown" instead of guessing, otherwise your density column quietly fills with garbage.

One practical decision: don't compute a verdict and throw away the inputs. Store the raw score, the registration date, and the page count alongside the label. When a number looks wrong later, you want to see which of the three inputs caused it.

Why keep the catalog in a SQLite table?

The automated rule will misfire. A single-page-app with client-side routing shows an empty sitemap and looks viral when it isn't. A docs site on a brand-new domain can have hundreds of pages. You need a place to override the machine, and that place is a table, not a code change.

A SQLite database fits this exactly: one row per domain, columns for the three raw inputs, the computed density, the auto-label, a manual-override label, and a note explaining why you overrode it. Use the in-platform SQLite editor to fix rows by hand after each run, so corrections live next to the data instead of in a spreadsheet you lose. Keep the auto-label and your manual label in separate columns; collapsing them means you can never tell how often the rule was wrong, which is the one piece of feedback that would improve the rule.

This also makes the job idempotent in a useful way. Re-running the scorer updates the raw inputs but leaves your manual overrides intact, as long as you write the merge logic to respect the override column.

What does the HTML board actually show?

The output is a single read-only board. Each site gets a card or row showing its label, its score, its domain age, its page count, and the density, with viral and SEO-driven visibly distinguished. You can run HTML online to host that page and share a link, which is enough for a weekly "here's what launched and whether it's copyable" post without standing up any infrastructure.

To feed the page from the database rather than hand-editing it, expose the table through a small API endpoint and have the page fetch its rows on load. Put the limits on the page itself, in plain text: small sample, HN-only, inference not traffic, numbers borrowed from the original experiment. A board that overstates its own certainty is worse than no board.

Where does the platform actually help?

Two things people will ask for that I'd flag honestly.

First, "make it run every week automatically." The confirmed capabilities here cover online Python execution and API endpoint hosting with in-platform tool calls, but I'm not going to claim a scheduler or cron feature that isn't in scope. Treat the weekly cadence as a manual or externally triggered re-run of the Python job, and if you need a true timer, that's a boundary to solve outside what I can promise here.

Second, "turn this into real traffic estimates." You can't, and neither could the original author. The method only ever answered the strategy question. Any visitor count would be invented, so leave it out.

If you want a knowledge layer later, pulling the scored domains and your notes into a LanceDB base to query past launches by pattern is a reasonable extension, and the publishing and monetization side could turn the weekly board into a shared or paid column. But the minimum viable version is the three pieces above: a Python scorer, a SQLite catalog you can fix by hand, and one HTML board. That's a weekend build, and it outlives the post that inspired it.

FAQ

What does the classifier actually score?

Launch signals from public endpoints: whether a site spiked and vanished, or kept accumulating pages and search traffic.

Why SQLite instead of a database server?

A single file with zero configuration handles a few thousand rows, and a mislabelled row can be corrected by hand in seconds.

Can this run without a server?

Yes. A Python job plus one HTML page is enough; the platform supplies the always-on runtime and the public link.

Further reading