Before You Build Your SaaS, Validate the Name

Before You Build Your SaaS, Validate the Name

You have an idea.

You pick a name.

The domain is available.

You start coding.

Two weeks later, you discover there is already an npm package with that name, a GitHub project using it, and a trademark registered for a similar product.

Now you're wondering whether you should rename the project before launch.

This is an expensive problem to discover late.

If you're building a SaaS, indie product, CLI, API, or developer tool, name validation should happen before you write the first serious line of code.

The 15-minute name validation checklist

You don't need a complicated branding process.

You need to answer one question:

Here's the checklist I use.

1. Check the domain

Start with the obvious one.

Check:

• .com
• Your preferred alternative TLD
• Common misspellings
• Hyphenated versions if relevant

But don't make the mistake of treating domain availability as proof that the name is available.

An available domain only means you can potentially register that domain.

It doesn't mean nobody else is using the brand.

2. Search GitHub

If you're a developer, this one is particularly important.

Search GitHub for:

"name"

Then try:

"name" SaaS
"name" app
"name" API
"name" developer

Look for:

• Existing products
• Popular repositories
• Companies
• Open-source projects
• Projects in the same category

A tiny abandoned repository isn't necessarily a deal-breaker.

A popular developer tool with thousands of users probably is.

Also check whether the obvious GitHub organization name is already taken.

3. Check npm and PyPI

If you're building something for developers, search package registries.

For npm:

npmjs.com/search?q=yourname

For Python:

pypi.org/search/?q=yourname

You want to know whether your name is already strongly associated with a package.

This becomes especially important if your product might eventually have:

@yourname/sdk
yourname-cli
yourname-api

A name that's already deeply established in the developer ecosystem can make distribution and discoverability harder.

4. Search the App Stores

Check both:

• Apple App Store
• Google Play

You don't need to reject a name simply because another app uses the same word.

Instead, ask:

Is there an established product using this name for something similar?

"Apple" being used by a company isn't the same situation as finding another developer tool called "YourProduct" serving exactly the same audience.

Context matters.

5. Search Product Hunt

Product Hunt is particularly useful for startup names.

Search for the exact name and variations.

You're looking for:

• Existing launches
• Similar products
• Companies that previously used the name
• Products with strong existing recognition

A product that launched years ago and disappeared isn't necessarily a blocker.

But it is useful information.

You don't want to discover after launch that your "new" product name already has years of search results attached to it.

6. Check social handles

At minimum, check:

• X
• LinkedIn
• Instagram
• YouTube

You don't necessarily need the exact handle everywhere.

But you should know what you're getting into.

For example:

Good:

Product: AcmeKit
X: @acmekit
GitHub: github.com/acmekit
Domain: acmekit.com

Less ideal:

Product: AcmeKit
X: @acmekit_dev_2026
GitHub: github.com/acme-kit-official
Domain: getacmekit.io

The second setup can still work.

But it creates more friction every time someone tries to find you.

7. Search company databases

Search for the name on places like:

• Crunchbase
• LinkedIn
• Google
• Your country's company registry

You're mainly looking for businesses operating in a similar space.

A company in an unrelated industry may not matter much.

A company selling software to exactly the same customers deserves much more attention.

8. Check trademarks before you commit

This is the check I would not skip.

Search the relevant trademark databases for your target markets.

For example:

• USPTO — United States
• EUIPO — European Union
• Your local trademark registry

Don't search only for an exact match.

Also search for:

• Similar spellings
• Singular/plural versions
• Phonetic variations
• Similar marks in related categories

For example, if you're building project-management software called:

TaskPilot

Don't only search:

TaskPilot

Also investigate similar marks such as:

Task Pilot
TaskPilot
Task-Pilot

And most importantly, look at what goods or services the trademark covers.

A trademark for a completely unrelated product is a different situation from one covering software services in your exact market.

If you find something concerning, that's the point where getting professional legal advice makes sense.

9. Check how distinctive the name actually is

Here's a test developers often skip.

Google the name.

Then search:

"name"
"name" software
"name" SaaS
"name" app
"name" API

If the first page is already dominated by another company, product, or concept, that's valuable information.

You don't necessarily need a name with zero search results.

You want a name where your product can eventually own the search results.

10. Don't validate names one at a time

This is where the process gets painful.

Suppose you have 10 ideas:

CodeNest
DevNest
ShipNest
LaunchNest
BuildNest
StackNest
DeployNest
CloudNest
AppNest
ShipStack

Checking one name manually across 10+ platforms means repeating the same work dozens of times.

Instead, create a simple spreadsheet:

You don't need perfect scoring.

You need enough information to compare your candidates objectively.

A simple scoring system

If you want to make this even easier, score each category from 0–2:

Then score:

• Domain
• GitHub
• npm/PyPI
• App stores
• Social handles
• Product Hunt
• Company search
• Trademarks

For example:

Domain:          2
GitHub:          2
npm:             2
App stores:      1
Social:          2
Product Hunt:    2
Companies:       2
Trademarks:      1
-------------------
Total:          14/16

That gives you a much better basis for choosing between five decent names.

What I would do before opening VS Code

For a new project, my workflow would be:

Generate 10–20 names
        ↓
Remove obvious conflicts
        ↓
Check domains
        ↓
Check GitHub + package registries
        ↓
Check apps + social handles
        ↓
Check Product Hunt + companies
        ↓
Check trademarks
        ↓
Shortlist 2–3 names
        ↓
Pick one
        ↓
Start building

The important part is the order.

Don't spend a week building before discovering a naming problem.

Spend 15–30 minutes investigating the name first.

One more thing: don't confuse "available" with "good"

A name can be completely unused and still be a terrible brand.

You should also ask:

• Can someone pronounce it?
• Can someone spell it after hearing it?
• Is it memorable?
• Does it sound like a real product?
• Does it make sense for the audience?
• Can you imagine saying it in a demo?
• Will you still like it in three years?

Availability is only one part of the decision.

The goal isn't to find a name that nobody has ever used.

The goal is to find a name that is distinctive enough, available enough, and low-risk enough to build around.

The easiest way to make this less painful

The problem isn't that any individual check is difficult.

The problem is doing the same checks repeatedly for every name.

If you're validating several SaaS ideas, tools that combine domain, platform, developer ecosystem, company, and trademark checks can save a surprising amount of time.

That's the entire reason I ended up building one myself.

Validate the name first.

Then open VS Code.

Your future self will thank you.