How to Name a Tech Startup

Write the positioning brief before the name

Most naming projects stall for a reason that has nothing to do with names: the founders argue about candidates while the claim underneath is still unsettled, so every candidate is judged against a moving target. A name is not good or bad in isolation. It is good or bad for a claim, and the claim has to exist on paper first. Three answers, one paragraph:

• Who says it out loudNot a market segment, an actual person: a platform engineer pasting it into a config file, a CFO reading it on an invoice, a teenager typing it into a search bar. A word that reads well in a deck can land badly in procurement.
• The category word beside itFinish “[Name] is the ___ for ___” in six words, without hedging. That noun is what your name must survive being placed next to, on your homepage and in someone else’s sentence. If it keeps moving, you do not have a naming problem yet.
• What you must never be mistaken forThe two or three adjacent things you would hate to be confused with: a competitor, a dead open-source project, a category you are deliberately not in. This converts vague dislike into a rejection rule you can apply forty times.

Write it before the first candidate and keep it visible while you judge. Its real job is arbitration: when co-founders disagree, the brief is what they point at instead of at each other’s taste.

The tech startup naming process: five steps and what each one outputs

Each step states its output, because a step with no artifact is a mood, and moods do not compose into a process.

1. Write the briefAnswer the three questions above in three sentences. Output: a one-paragraph brief you can hold next to any candidate. Budget an hour. It is the only step where more time reliably buys a better outcome.
2. Generate far more than you needAim for forty written candidates before judging one. Generation and judgment use different muscles, and interleaving them kills the good weird ones at birth. Output: an unfiltered list of forty.
3. Cut on hard constraints onlyOne pass, no favourites: kill anything unspellable from sound, anything already shipping in your category, anything whose package name is gone in your ecosystem, anything flagged in a language you sell into. Output: eight to twelve survivors.
4. Score the survivors identicallySame criteria, same scale, same day, written down. Numbers hold still; impressions drift toward whichever name you said aloud most recently. Output: a score plus a one-line justification per name per category.
5. Commit, then register in one sittingTake the domain, the package name, the organisation handle, and the container namespace within the hour, before the pick turns provisional again. Output: a name, a registered surface, and a dated decision.

Three of those steps hand off rather than repeat: fifty tech startup brand name ideas covers generation, how to test a brand name covers vetting a single candidate, and how to choose between two business names covers the endgame. Whether yours should describe what you do or stay abstract is a fourth decision the brief makes for you, and it has its own guide too.

Why tech sub-sectors name differently

“Tech” is not a naming register. A developer tool, a fintech product, and a piece of infrastructure are sold to different people under different anxieties, and each convention answers a pressure rather than a fashion. Knowing it lets you meet the expectation cheaply, or break it on purpose and know the cost.

• Developer toolsTerse, lowercase, often a borrowed word with a Latin or Greek root. Kubernetes is the Ancient Greek kubernetes, helmsman or pilot, the root that also gives us cybernetics. Vite is French for “quick”. Deno is an anagram of Node, from the person who built Node. The convention exists because the name is typed rather than read: it becomes a command, an import line, a directory, and every extra syllable is taxed on every keystroke. Break it when the buyer never opens a shell.
• AIShort abstract or borrowed words rather than descriptive compounds. The pressure is technique churn: a name built from the current method dates itself the moment the method moves. Abstraction buys the right to change what the product does without the name arguing back. The convention is not universal, and its most visible counterexample is the plainly descriptive OpenAI, which predates it. Break it when you sell one durable capability to a buyer who needs to know what it is before clicking.
• FintechSolidity and competence, usually through ordinary English words carrying a trust adjacency: Affirm, Wise. Money makes people conservative, and a playful name raises a question at the exact moment someone is deciding whether to move funds. The deliberate counter-pattern is flat concrete nouns with no financial meaning, like Stripe or Plaid, which read as infrastructure. Break the convention when you are selling against incumbent gravitas.
• InfrastructureStructural and elemental metaphors. Terraform is an English word for making a hostile planet habitable; bedrock is the solid rock beneath the loose material. The metaphor argues before the documentation gets a chance, and infrastructure is bought on the promise that it holds while you sleep. The failure mode is a crowded metaphor space: foundations, keystones, and pillars are heavily worked ground. Break it for a developer-facing primitive, where the dev-tool convention outranks this one.

Breaking a convention you can state in a sentence reads as a position; breaking one you never articulated reads as not knowing it. Put that sentence in the brief.

The namespaces only technical founders collide with

Every founder checks the domain. Technical founders have four more surfaces that can be quietly occupied, and they tend to find them too late: ten minutes before the first release. Checking costs ten minutes for a whole shortlist, and belongs in the cutting pass, not after the decision.

• The package registryCheck your primary ecosystem: npmjs.com/package/yourname, pypi.org/project/yourname, crates.io/crates/yourname. npm blocks a name only when it is identical to an existing package once punctuation is stripped, so a hyphen or a dot will not free up a taken name. npm also has scopes, so a taken bare name survives as @yourorg/yourname, while PyPI and crates.io are flat first-come namespaces.
• The organisation handleLoad github.com/yourname and see whether it resolves or 404s. This compounds hard, because the handle sits in every repository URL, every raw-content link, every CI badge, and every install command. Squatting is common on short words, and reclaiming one is slow and not guaranteed.
• The CLI binary nameThe single word people actually type. Search the Homebrew formulae and the Debian and Ubuntu package indexes, then try running it on a clean machine. Two things claiming one binary means whichever comes first on the PATH wins, and the loser looks broken.
• The container namespaceIf you will ever ship an image, hub.docker.com/u/yourname is a namespace someone else can hold, and that path gets quoted in every deployment manifest your users write. Seconds to check, and it prevents the most expensive rename: the one after release.

The point worth internalising: a taken package name is a real constraint even when the .com is wide open, and founders underweight it because the domain is the check they have heard of. A buyer types your domain once. A user types your package name, your binary, and your image path every working day, and each one gets copied into their code and their CI config.

Said plainly: Namoly does not check any of these. It scores the name, not the namespaces. No npm, PyPI, or crates.io lookup, no GitHub handle check, no container-registry check, and no trademark or social-handle screening. Run those four by hand; use the report for the properties of the word itself.

The shortlist funnel: a startup name checklist from forty candidates to one

The shape is forty candidates down to one, and the stages do not mix: facts cut first, scores cut next, and the last call is judgment. Mixing them up turns a week into a quarter.

Forty, not ten. The first ten you write are the ones your category has already used, and they are worth writing anyway to clear them out. The names that survive scoring arrive once the obvious patterns are exhausted and you stop describing the product.

Forty to twelve is one pass on hard constraints. No debating, no favourites, no “but I love it”. A hard constraint is a fact, so nobody has to win an argument:

• It cannot be spelled from soundSay it once to someone who has never seen it written and ask them to type it. Corrections are not a style opinion, they are customers arriving somewhere else.
• Your category already ships oneNot a distant company in an unrelated industry, but a product your buyer could plausibly confuse with yours. Your brief already wrote this rule.
• The namespaces are takenThe package name in your primary ecosystem, plus the organisation handle. Gone in both is usually fatal for a technical product, however good the word is.
• Nothing ownable on the domain sideCheck the extensions your buyers trust, and treat every result as worth verifying rather than as fact, since registries move by the minute.
• It is flagged in a market you enterActually enter, not aspirationally list. A screen reporting no flags in the languages checked is a real result; a tool calling a name “safe everywhere” is telling you about itself.

Expect that pass to be brutal, and let it be. If the .com is the only obstacle left, that has its own playbook in the pivot guide.

Twelve to three is scoring, then three to one is nerve. Score the survivors on identical criteria in one sitting, then make the call. The testing guide covers how to score a single candidate honestly, and the tiebreak guide covers how to separate the last two and when to stop. Set the decision date in the brief on day one.

Where an automated score fits in the process

Step four is the one you can hand to a machine, because everything it measures is a property of the string rather than an opinion about it. Namoly scores a name on four weighted categories: domain availability (0.30), memorability and distinctiveness (0.25), phonetics and readability (0.25), and cross-language safety (0.20). The overall is the weighted mean, and the bands are 80–100 Strong, 60–79 Good, 40–59 Fair, 0–39 Weak.

The analysis is deterministic: the same name returns the same scores for the same reasons every time, with no generation step and no dice roll, which is exactly what you want when twelve candidates have to be comparable. Every category also carries a plain-English justification and a confidence signal, so a shaky result never presents itself as a confident verdict.

Running an analysis is free, and so is re-running one. Score all twelve survivors in a few minutes, read the justifications rather than only the numbers, and spend your slow human tests on the three that earned it.

Frequently asked questions

How do I name my tech startup?

Work in five steps: write a one-paragraph positioning brief, generate around forty candidates without judging them, cut in one pass on hard constraints only, score the survivors on identical criteria, then commit and register the domain and namespaces in a single sitting.

How many startup name ideas should I generate?

Forty is roughly where diminishing returns set in, not an arbitrary target. Stop earlier and you never get past the first predictable batch everyone writes; push toward a hundred and the extra hours mostly reword ideas you already have.

Does a tech startup name need to be a real word?

No, and there are strong examples in both directions. A real word is easier to spell from sound and harder to own; a coinage is easier to own and costs you a few months of people typing it wrong. Your brief decides it, not the sector fashion.

Should I check package names before choosing a startup name?

Yes, during the cutting pass. On npm a taken name is survivable, because scopes let you ship as @yourorg/yourname. On PyPI and crates.io there are no scopes, so it is a genuine wall. A buyer types your domain once; a user types your package name daily.

Does Namoly check package registries or trademarks?

No. Namoly scores the name itself on four deterministic checks: domain availability, memorability and distinctiveness, phonetics and readability, and cross-language safety. It does not check npm, PyPI, crates.io, GitHub handles, container registries, trademarks, or social handles.

How long should naming a startup take?

Put a deadline in the brief, because naming expands to fill whatever time it is given. A week of deliberate work is usually enough: an hour on the brief, an evening generating, one pass to cut, a day to score, then a decision. Projects that run for months lack a stopping rule.