The story behind OpenLookup
How rebuilding the same email validation flow for the fourth time turned into a developer API company.
The trigger
It was a Tuesday, and I was writing an email validation flow. Again.
Not the same code — a new codebase, a new product, but the same flow: regex, MX check, disposable-domain list, rate limiting, a cache layer, error states. The fourth variation in two years. Each one slightly different and slightly worse, because each was written in a hurry to get back to the actual product.
Somewhere around wiring up another disposable-domain list, the obvious finally landed: if I keep rebuilding this, so does everyone else.
The problem
Every signup form, every API, every SaaS needs the same verification primitives — is this email real, is this phone reachable, is this signup human. And every team solves it with the same pile of half-measures, because the good solutions are locked behind enterprise sales calls and SDKs that feel older than the frameworks they target.
Verification is infrastructure. Infrastructure shouldn't have a discovery call.
The first attempt
The first version was a single endpoint: validate an email. I shipped it in a weekend and pointed our own products at it. It worked — mostly. The "mostly" is where the real product started:
- Provider outages caused silent partial results, which is the worst kind of wrong
- Caching by freshness was harder than caching by TTL
- The error format I'd invented was inconsistent with itself
What changed
We stopped treating it as a utility script and started treating it as a product with the same bar as anything we ship publicly: proper architecture, provider failover, honest responses that say exactly what was checked and what was skipped, one consistent error format, and flat public pricing.
The design principle that emerged: no silent partial results. If a check didn't run, the response says so. Trust is the entire product.
Where it's going
OpenLookup is in private testing now, heading toward public launch. The roadmap is boring in the best way: more signals, better latency, SDKs that don't embarrass anyone.
You can follow along on the OpenLookup product page.