Most indie developers I talk to have the same story: the code took a weekend, the name took a week. You can scaffold a working product with AI assistance in an afternoon, but you'll still burn three evenings staring at a registrar search box wondering whether to grab the .app, the .dev, or the .io.
I spent a decade brokering domains, and the indie dev TLD question is one of the most common I get — partly because the trade-offs are genuinely non-obvious. These three extensions look interchangeable on the surface. They are not. One of them will refuse to load without an SSL certificate. One of them will quietly charge you five times more at renewal. And one of them signals "I build for developers" louder than the other two.
This guide is the decision framework I wish every builder had before checkout: how each extension actually behaves, what it signals to your audience, what it costs over time, and a one-hour workflow to lock the right name and get back to shipping. Every domain featured here is a flat $199.
The Indie Developer Naming Problem: Ship First, Name Fast
The modern build workflow has inverted the old order of operations. It used to be: pick a name, buy the domain, then spend months building. Now you build first — often with an AI pair-programmer — and the name becomes the last blocker between a working repo and a public launch.
That creates a specific kind of pressure. You don't want to spend two days on naming when the product is already running on localhost:3000. But you also don't want to slap on a throwaway name you'll have to migrate off in six months, eating the SEO and the muscle memory of every user who bookmarked it.
The answer for most indie developers is a short, clean, brandable name on a modern technical TLD — .app, .dev, or .io. These extensions have wide availability (you can still get one-word and two-word names that vanished from .com a decade ago), they signal that you're a builder, and they cost a fraction of a premium .com on the aftermarket. The only real decision is which one.
.app vs .dev vs .io: The Core Differences That Actually Matter
Here's the head-to-head comparison every founder should see before picking an extension. The differences in security behavior and renewal cost are the ones that surprise people after purchase.
| Factor | .app | .dev | .io |
|---|---|---|---|
| Operated by | Google Registry | Google Registry | Identity Digital (ccTLD) |
| HTTPS required | Yes — HSTS preloaded | Yes — HSTS preloaded | No (HTTPS optional) |
| Typical renewal | ~$15–$20/yr | ~$15–$20/yr | ~$40–$70+/yr |
| Best signal for | Apps end-users open | Dev tools, libraries, docs | APIs, CLIs, B2B dev SaaS |
| Audience read | "This is an application" | "Built by/for developers" | "Serious developer tooling" |
| Availability | High — many words open | High — many words open | Moderate — more taken |
| Political note | None | None | ccTLD of Brit. Indian Ocean Terr. |
The single biggest "gotcha" lives in two of those rows — the HTTPS requirement and the renewal cost. Let's take each in turn.
Why .app and .dev Force HTTPS (and Why That's Good)
This catches first-time .app/.dev buyers off guard, so it's worth being precise: both .app and .dev are on the HSTS preload list maintained by Google Registry. Practically, that means every modern browser ships with these TLDs hard-coded to connect only over HTTPS. There is no plain-HTTP fallback. If your .app site doesn't have a valid SSL certificate, the browser shows a security error instead of your page — the HSTS preload mechanism is enforced before any request even reaches your server.
If you're an indie developer, this is almost certainly a non-issue dressed up as one. Modern hosting makes HTTPS automatic and free:
- Let's Encrypt issues free, auto-renewing certificates that every major host supports.
- Vercel, Netlify, and Cloudflare Pages provision SSL automatically the moment you point a domain at them.
- Most managed hosts include one-click or zero-click certificates out of the box.
So the "requirement" usually amounts to: deploy your project the way you already were going to. In exchange, your product is encrypted by default with zero chance of accidentally shipping an insecure connection — a genuine security win baked into the extension. Google's own registry pages for .app and .dev lean into exactly this positioning: secure-by-default domains for builders.
.io, by contrast, does not enforce HTTPS. You should still use SSL (you always should), but nothing about the TLD requires it. If you genuinely need a domain that can serve plain HTTP for some legacy reason, .io is the only one of the three that allows it — a niche consideration, but a real one.
What Each Extension Signals to Your Audience
Domains are a trust and positioning signal before they're anything else. The right extension tells a visitor what kind of thing they're looking at within a quarter-second of reading the URL.
.app — for things people open and use
.app reads as "this is an application." It's the cleanest fit for a consumer or prosumer product with a UI — a mobile app's marketing site, a web app, a productivity tool. It pairs naturally with an app-store presence and tells a non-developer visitor exactly what to expect.
.dev — for things built by and for developers
.dev is the developer's home turf. Launched and operated by Google Registry, it signals "made by a builder" and is the natural choice for developer tools, open-source projects, documentation sites, portfolios, and internal engineering resources. If your audience is other developers, .dev builds instant credibility.
.io — for APIs, CLIs, and developer-facing platforms
.io carries the longest track record of the three in developer culture. It reads as "input/output" and has become shorthand for serious technical tooling — APIs, command-line tools, B2B SaaS platforms, and infrastructure products. It's the most established and the most instantly "techy."
The trade-off with .io is twofold. First, renewal cost: .io is a registry-premium ccTLD and typically renews at $40–$70+ per year, versus roughly $15–$20 for .app or .dev. Over a five-year brand horizon that's a real difference. Second, .io is technically the country-code TLD of the British Indian Ocean Territory, and a small number of teams avoid it for very long-horizon brands on that basis. Neither point disqualifies .io for most indie tools — but both belong in your decision.
Browse the full set of developer and keyword domains to see what's available across all three extensions at a flat $199.
Price and Availability: The Total Cost of Ownership
Acquisition price is only half the picture. The number that matters over the life of a project is total cost of ownership — acquisition plus renewals. Here's how the three stack up against a premium aftermarket .com, the option most indie devs are implicitly comparing against.
| Cost factor | Premium .com (aftermarket) | .app / .dev | .io |
|---|---|---|---|
| Acquisition (good name) | $2,000–$50,000+ | $199 flat (curated) | $199 flat (curated) |
| Annual renewal | ~$10–$15 | ~$15–$20 | ~$40–$70+ |
| HTTPS setup | Optional | Required (free via Let's Encrypt) | Optional |
| Availability of short names | Very low | High | Moderate |
| Time to launch | Weeks of negotiation | Instant checkout | Instant checkout |
The arbitrage is obvious. A clean one- or two-word name that would cost five figures on a .com aftermarket is frequently available on .app, .dev, or .io — and on a flat-rate marketplace, it's a single $199 checkout with no negotiation. For the full breakdown of why aftermarket .com prices balloon while modern TLDs stay affordable, see how to get a premium domain for under $500 and our comparison of flat-rate vs. auction domain pricing.
How to Pick Your Developer Domain in Under an Hour
You don't need a week. Here's the sprint I recommend to indie developers who want to stop deliberating and ship.
Step 1 — Define what you're shipping (5 minutes)
Write one sentence: "It's a ___ for ___." If the blank is "app for end-users," lean .app. If it's "tool/library/resource for developers," lean .dev. If it's "API/CLI/platform for engineers," lean .io.
Step 2 — Generate 8–10 name candidates (15 minutes)
Short and pronounceable beats clever. Aim for one or two words under 12 characters total. Apply the say-spell-search test: can you say it on a call, spell it without repeating yourself, and search it without ambiguity? We cover this naming logic in depth in the best domain names for SaaS startups.
Step 3 — Sweep availability across all three TLDs (15 minutes)
Check your top candidates on .app, .dev, and .io together. A curated flat-rate catalog speeds this up enormously because every listing is already vetted for clean history and trademark conflicts — you're choosing from pre-screened names, not gambling on the open aftermarket.
Step 4 — Decide and buy (15 minutes)
When two extensions are available for the same word, default to the cheaper-to-renew option (.app/.dev) unless the .io association is core to your positioning. Lock it, point your host at it, let SSL auto-provision, and get back to the code. For the deeper psychology of why certain names convert better, see SaaS naming psychology.
The Bottom Line for Indie Developers
There's no universally "best" extension — there's the best extension for what you're shipping. .app says application. .dev says built by a developer. .io says serious technical tooling, at a higher renewal cost and with a ccTLD footnote. All three give you access to short, brandable names that disappeared from .com years ago, and all three signal "modern builder" to the audience that matters.
The mistake isn't picking the "wrong" one of the three — it's letting the decision stall your launch, or overpaying five figures for a compromised .com when a clean .dev would have served you better for $199. Match the extension to your product, make sure HTTPS is handled (it almost certainly is), and ship.
Browse the curated catalog of developer and keyword domains — every .app, .dev, and .io a flat $199, vetted for clean history and ready to transfer within 72 hours. Or start with our companion guides on keyword domains and brandable domains to nail the style of name before you pick the extension.
