Startup Radar

About

Why this exists, and how it was built

The decisions and lessons behind Startup Radar.

Read the product-facing methodology · Browse the source · Export the current dataset (JSON)

Why I built this

I wanted to understand what it actually takes to evaluate something as uncertain as an early-stage startup, not by reading about it, but by building a system that has to make that call, over and over, on real companies, and show its work every time. Startup Radar is a discovery engine: it finds emerging companies from public sources like funding announcements, accelerator cohorts, and stealth launches before they’re widely covered, and records confidence and source links so readers can examine the evidence themselves.

The current directory contains 303 companies, discovered and ranked by code. Source links support independent review, and an incorrect match can still require correction.

The decision I keep coming back to: deterministic over agentic

The first version of Scout (the discovery engine) worked the way you’d probably guess: one Claude call per category (funding, stealth, or launches), using web search and web fetch to both find candidates and verify them. It worked. It also took roughly 20 minutes for a single category on a real run, and the worst-case cost per request ran to roughly $2+ against a budget I’d set at $0.75 per run. An open-ended agentic loop simply can’t run daily under a fixed, honest cost ceiling; the ceiling would refuse it almost every time.

So I rebuilt discovery as a fully deterministic pipeline: real RSS and directory feeds, regex/heuristic extraction, rule-based filtering, a transparent weighted ranking, zero LLM calls anywhere in the path, enforced by a static test that fails the build if an Anthropic import or a model name ever appears under that code. It now runs daily, unattended, for effectively free.

That’s the opinion I’d defend: AI is genuinely good at narrow, bounded judgment calls on already-surfaced evidence, not at being the thing that goes and finds the evidence in the first place, when a few hundred lines of deterministic code can do that more cheaply, faster, and more reproducibly. Reserve the model for the part a rule genuinely can’t do.

A mistake I shipped, caught, and reverted

At one point I built a feature to guess a company’s domain from its name when the real source URL was an unfetchable redirect, verifying each guess by checking whether the company’s name appeared on the resulting homepage. In a live precision audit, two of the first ten guesses it “verified” were wrong in a specific, bad way: a funded startup called Ande matched ande.com, which is actually ANDE, an unrelated, already-established forensic DNA-testing company. A startup called Travix matched travix.com, an unrelated 450-employee travel agency.

Both passed verification because the real, different company’s own homepage naturally contains its own name. The check was proving a name collision, not an identity match. I reverted the feature completely rather than ship something that could attach a real company’s profile to the wrong business. The core rule I took from it, now written into the project’s own engineering notes: a wrong domain is worse than a missing company. An unresolved match is the correct outcome when evidence is thin, not a bug to paper over.

What’s under the hood

The full technical writeup covering the pipeline, safeguards, and limitations lives in the project’s own engineering notes alongside the code. The short version: a $0.75 hard budget ceiling with pre-flight reservation, an append-only ledger of every lead found regardless of outcome, an offline snapshot/replay system so the entire test suite runs with zero network calls and zero spend, and two, and only two, files in the whole codebase allowed to write to the database, each one enforced by a static test that inspects every write call by name.