← All posts
Strategy6 min readBy ZeroTaken Team

Is the Domain the Only Name You Need to Lock Down? The Developer Namespace Checklist

Founders treat the domain as the finish line: the .com clears, they register it, they celebrate. Then a week later the npm package is gone, the GitHub org belongs to a dormant account from 2014, and the App Store name is taken by a flashlight app. For a developer-facing product, the domain is only one of five or six namespaces your brand has to live in, and a few of them are far harder to fix than a domain. This guide gives you the checklist, the order to claim things in, and the two places where a mistake is effectively permanent.

Add ZeroTaken as a preferred source on Google
Is the Domain the Only Name You Need to Lock Down? The Developer Namespace Checklist

Why does one missing namespace hurt more than a missing .com?

A domain is the one namespace you can always buy your way into: the owner has a price, and there is a transfer process. Package registries and app stores don't work like that. Names are first-come, there is no marketplace, and the dispute process is slow and conservative. If someone else holds your name on npm, your install command is permanently different from your brand.

That matters because for developer tools the install command is the marketing. Every README, tutorial and Stack Overflow answer repeats it. If the brand is Quillstack but the package is quillstack-js, quill-stack-sdk or @someone/quillstack, you pay a small confusion tax in every single support thread.

So the real rule is: a name isn't taken until you've checked every place a user will have to type it.

Which namespaces should you actually check?

Not all of them, and not equally. Rank them by how often your users will type the name and how hard it is to change later.

  • Domain (.com first, then your fallback TLD): every user sees it, and you can recover from a miss. Check it before you fall in love with the name.
  • GitHub organisation or username: this becomes github.com/yourbrand in every link. Org names are unique across users and orgs, and a dormant account that holds the name is usually not reclaimable.
  • Package registry names (npm, PyPI, crates.io, RubyGems, whichever your users install from): first-come and effectively permanent. Check every registry your product will ship to, not just the first.
  • Social handles (X, LinkedIn, YouTube): important for discovery, easy to live without. A trailing underscore is annoying but survivable.
  • App store listing and bundle ID, if you ship mobile: the store name can be adjusted, but the bundle or package identifier is locked in once you publish.
  • Container and extension registries (Docker Hub, VS Code Marketplace, browser extension stores): only if your product is distributed that way.

What are the two namespaces you can't change later?

The first is your package name on a registry. You can publish a new package under a new name, but you can't move your existing users, your download history, or every blog post that says to install the old one. Deprecating a package and pointing to a successor works, but it is a migration project, not a rename.

The second is the mobile app identifier. On Google Play, the application ID you publish with is permanent for that listing, and Apple bundle identifiers are tied to your signing and provisioning setup. You can change the display name freely. You cannot change the identifier without effectively shipping a new app and losing reviews and installs.

Both mistakes share a pattern: the name was chosen casually in week one, in a placeholder repo, and then became load-bearing. If you take one thing from this guide, treat the first `npm init` or the first app project as a naming decision, not a scaffold.

What order should you claim names in?

Go from hardest-to-recover to easiest, but check them all before you pay for any. The sequence that avoids heartbreak is a quick check pass first, then a claim pass.

In the check pass, search every namespace for your top three names. Kill any name that fails on a namespace your users type often, such as the domain or the primary package registry. A name with a clean .com but a squatted package is a worse pick than a name with a clean .io and a clean package.

In the claim pass, register the domain and create the GitHub org first, because both are free of side effects. Then publish a minimal placeholder package to each registry you'll use so the name is held under your account. Finish with the social handles. Mobile identifiers wait until you have a real app, but reserve the store name early if the store lets you.

  • 1. Check all namespaces for your top three names (15 minutes, no money spent).
  • 2. Drop any name that fails on the domain or the primary registry.
  • 3. Register the domain and create the GitHub org the same day.
  • 4. Publish a minimal, honest placeholder package to each registry you'll use, with a README that says what's coming.
  • 5. Claim the social handles last; they matter least.

Is it fine if the names don't match perfectly?

Sometimes. A small, consistent deviation is fine; a different word is not. Using getquillstack.com while the package and org are both quillstack is a common, tolerable pattern. Using three different spellings across three places is not, because users will guess wrong and search results will split.

Be careful with registries that treat punctuation as equivalent. PyPI normalises hyphens, underscores and dots, so names that differ only in those characters collide. npm also refuses names that are too close to an existing package. That means the clever variant you were counting on, such as quill-stack when quillstack exists, may be rejected outright.

If the exact name is gone on one registry, consider a scope instead of a rename. On npm, publishing under your own scope, @yourbrand/core, keeps the brand intact and gives you a whole namespace for future packages. It is the one workaround that doesn't leave a permanent mismatch.

What should you do when a namespace is already taken?

First, look at what is actually there. A name held by a live, maintained project is off the table, and trying to claim it can create a trademark-flavoured conflict you don't want. A name held by an empty placeholder or an abandoned account is a different story, but registries have their own policies for reclaiming names and they are slow, so don't plan your launch around them.

Second, decide whether the miss is a dealbreaker using one test: would a developer who sees your brand name guess the install command correctly? If yes, you can live with a slightly different org name or social handle. If no, pick a different brand name now, while it costs you an afternoon rather than a rebrand.

Third, if the name is otherwise perfect, a one-word modifier applied consistently everywhere beats a different spelling on each platform. Consistency is what users remember, not the purity of the bare word.

How does this fit into your normal naming process?

Add the namespace pass between shortlisting and committing. Your shortlist already gets filtered by pronunciation, length and trademark risk; the namespace check is just one more cheap filter, and it kills names that would otherwise cost you months later.

Start with the domain, since that's the most expensive and most visible check. A quick search on ZeroTaken tells you whether your candidate is free across the extensions you care about, and then you can run the registries and GitHub in a few minutes by hand. Do the whole sweep before you register anything.

The goal isn't to own every possible variant of your name. It is to make sure that on the day a developer first hears about you, the domain, the repo, the package and the app all spell it the same way.

Add ZeroTaken as a preferred source on Google