Every time I start a new project — my own or a client's — I do the same thing. Open 15 tabs. Type the name into domain registrars, GitHub, npm, the App Store, Twitter. Cross-reference. Forget one tab. Reopen it. Repeat. It's the least fun part of naming anything, and it never gets faster.
So I built Hustle Namechecker. One input field. Type a name. Get a full availability check across domains, social handles, dev registries, app stores, and trademark databases. No account. No pricing page. No upsell.
It's the kind of tool where you check startup name availability once, get your answer, and close the tab. That's the entire point.
What It Checks
The tool runs checks across six categories. You type a name, hit enter, and every result loads in parallel.
Domains
Common TLDs that matter for SaaS and startup products. .com, .io, .dev, .app, .de, and the rest of the usual suspects. Each result links directly to a registrar so you can buy immediately if it's free.
Social Handles
@yourname across the platforms that matter: X (Twitter), Instagram, LinkedIn, TikTok, YouTube, and others. Knowing upfront whether your brand name is taken on every major platform saves the awkward discovery at launch that you'll be @yourname_official forever.
Dev Registries
This is where it gets useful for developers specifically. NameChecker queries npm, PyPI, crates.io, Homebrew, RubyGems, NuGet, and more. If you're building a library, a CLI tool, or an open-source project, the package name matters as much as the domain. Finding out after you've written a README that your name is taken on npm is a special kind of pain.
GitHub
Checks both user/org availability and whether a repo with that name exists. If you plan to open-source anything — or even if you want github.com/yourname to look clean — this matters early.
App Stores
Searches Apple App Store and Google Play for existing apps with similar names. Not a trademark check — but a useful gut check on whether the name space is crowded.
Trademarks
Trademark databases can't be queried programmatically in any reliable way. NameChecker provides quicklinks to the relevant databases — EUIPO, USPTO, DPMA — so you can search manually. Honest about what automation can't do.
Why Build This When Alternatives Exist
There are other name checkers. Namechk, Namecheckr, KnowEm. They've existed for years.
Most of them are slow. Many require an account before showing full results. Some gate features behind a paywall. Several are littered with affiliate links to domain registrars, which means the "available" results are incentivised to lead you toward a purchase, not toward accuracy.
I wanted something with zero friction. No account. No tracking beyond basic analytics. No affiliate links. No "upgrade to pro for full results." Type a name, get an answer.
The other angle: most existing tools focus on domains and social media. They don't check npm. They don't check PyPI or crates.io. If you're a developer naming a library or a CLI tool, those registries are the first thing you need to check — and the last thing existing tools bother with.
The Weekend Build
NameChecker is a Next.js app. The stack:
- Next.js with App Router
- TypeScript throughout
- Server actions for the availability checks (some are API-based, some are DNS lookups, some are HTML scrapes)
- Deployed on Vercel — this is a stateless tool, no database needed
- Umami for privacy-friendly analytics
The initial version took a weekend. Not a "weekend" in the startup sense where it means three weeks of evenings. An actual Saturday and Sunday.
The architecture is straightforward. The frontend is one form component and a results grid. The backend is a set of check functions — one per service — that run in parallel on the server. Each check returns one of three states: available, taken, or error (for when an API is rate-limited or unreachable).
// Simplified structure of a check function
async function checkNpm(name: string): Promise<CheckResult> {
const res = await fetch(`https://registry.npmjs.org/${name}`, {
method: "HEAD",
});
if (res.status === 404) return { status: "available" };
if (res.status === 200) return { status: "taken" };
return { status: "error" };
}
Most services are variations of this pattern. Hit a known URL, interpret the status code. npm returns 404 for packages that don't exist. GitHub's API does the same for users and orgs. DNS lookups for domains. Some services require scraping a search results page — app stores, for example — which is brittle but functional.
The whole thing runs without a database. No state to manage. No user accounts to handle. No data to store, back up, or worry about under GDPR. Stateless tools are underrated.
Design Decisions That Mattered
A few choices shaped the final product more than the code did.
Terminal aesthetic. The UI uses a monospaced font and a command-line style input (~/hustle » your-idea-here). This isn't decoration. It signals who the tool is for — developers and technical founders. It also sets expectations: this is a utility, not a SaaS product. You use it, you leave.
Parallel execution. All checks run simultaneously. The results page fills in as each check completes, fastest first. Nobody wants to wait for a sequential crawl across 30 services. Perceived performance matters more than actual performance in a tool like this — showing the first result in 300ms while the rest trickle in over 2 seconds feels fast. Showing all results after a 2-second wait feels slow, even though the total time is identical.
No signup wall. This was the hardest non-decision. The reflex is to add an email capture. "Enter your email to save results." It would generate leads. But it would also add friction to a tool whose entire value proposition is zero friction. I left it out. The tool links back to CodeAttack. That's enough.
Bilingual. The site supports both English and German, matching the DACH startup audience I work with. Not a major engineering effort with next-intl, but it widens the useful audience.
What I Learned About Shipping Small Tools
Scope is everything
The original idea included a "name scoring" feature — rate how brandable a name is based on length, pronounceability, memorability. I cut it before writing a single line of code. Scoring is subjective. It adds complexity. It invites arguments about methodology. The tool does one thing: tells you if a name is taken. That's a question with a concrete answer.
The 80% that works beats the 100% that ships next month
Some checks are imperfect. App Store search results don't mean the name is trademarked. A DNS lookup can't tell you if a domain is parked but available for purchase. The tool is honest about these limitations — it shows what it can verify, links to what it can't, and doesn't pretend to be a legal opinion.
Shipping the imperfect version and iterating based on actual use was more productive than trying to solve every edge case upfront.
Dev tools don't need to be products
NameChecker has no pricing. No premium tier. No roadmap page. It's a sharp tool that solves a specific problem, and it links back to CodeAttack as a demonstration of how I work: fast, focused, no unnecessary complexity.
Not everything needs to be a business. Sometimes a tool is a tool.
The Ongoing Cost
The tool runs on Vercel's free tier. No database, no storage, no background jobs. The only cost is the domain and Umami analytics (which runs on existing infrastructure).
Total monthly cost: roughly €1 for the subdomain DNS. That's it. A useful public tool for the price of a bad espresso.
When to Build a Weekend Tool
The pattern works when three conditions are true:
- You have the itch. You're already doing the task manually, repeatedly, and it annoys you.
- The scope is containable. One input, one output. No user accounts, no complex state, no third-party auth flows.
- You're comfortable with "good enough." The tool doesn't need to handle every edge case. It needs to save time in the common case.
If all three hold, build it. Don't plan it. Don't write a PRD. Don't set up a project board. Sit down on Saturday morning, ship by Sunday evening, and see if anyone else finds it useful.
NameChecker started as a scratch-my-own-itch tool. It turned into something I use on every new project — mine and clients'. The next time you're naming something, try it: namechecker.codeattack.io.