Overview
Domain Triage lets indie developers and founders batch-check domain availability during brainstorming sessions. Paste up to 20 candidates, get honest results backed by DNS and RDAP evidence, drill into details, build a shortlist, and export — all from a single page that costs almost nothing to operate.
- Batch checking: Up to 20 domains per run with two input modes — full domains or base names with selectable TLDs
- Honest results: Three-state model (registered, available, unknown) — never claims “available” without definitive evidence
- Drill-in evidence: DNS records, RDAP registrar data, heuristics, and confidence levels for every domain
- LLM-ready API: Public versioned endpoint callable by Claude, ChatGPT, and other AI tools
Problem
Domain brainstorming is tedious. Checking availability one by one at registrars is slow, results are unreliable, and there's no good way to compare and shortlist candidates.
Slow iteration
- Manual one-at-a-time checks at registrars
- Context switching between naming and checking
- No batch workflow for brainstorming sessions
Untrustworthy results
- Registrars show conflicting availability
- No evidence behind “available” claims
- Front-running concerns after checking
No comparison tools
- No side-by-side candidate evaluation
- No shortlist or export functionality
- Results disappear after closing the tab
Solution
A full-stack serverless application with a TypeScript monorepo, server-side DNS/RDAP checks, transparent evidence for every result, and a complete brainstorming workflow from input to export.
Core design decisions
- Server-side checks: DNS and RDAP queries run on Lambda — avoids CORS limits, prevents abuse exposure, enables rate limiting
- Honesty rule: Default to “Unknown” when uncertain — only claim “Available” with definitive proof
- DynamoDB caching: 15-minute TTL balances freshness vs. cost for rarely-changing data
- Versioned API:
/api/v1/ensures stable contracts as the product evolves
Evidence model
Every domain result is backed by concrete evidence — not guesswork. The three-state availability model ensures users always know the confidence level behind each result.
| Check layer | What it reveals |
|---|---|
| DNS resolution | Parallel A, AAAA, CNAME, and NS queries with 5s timeout — any record present means registered |
| RDAP lookup | Registrar name, creation/expiration dates, domain statuses — confirms registration with authority data |
| Heuristics | Domain length scoring, hyphen/number penalties, TLD quality signals — helps compare shortlist candidates |
Three-state availability
- Registered: DNS records or RDAP data confirm the domain is taken
- Available: No DNS records and no RDAP registration — definitive evidence of availability
- Unknown: Ambiguous or error state — never falsely claim available when uncertain
Drill-in panel
- Status summary with confidence level
- Raw DNS records and RDAP data with timestamps
- Heuristic scores and quality signals
- Quick actions: copy, open registrar, Google search, add notes, retry check
UX state machine
The frontend follows a 7-phase state machine that guides users through a complete brainstorming workflow — eliminating ambiguous UI states and making every transition intentional.
| Phase | What the user sees |
|---|---|
| 1. Input | Paste domains or enter base names with TLD selection; validation feedback in real time |
| 2. Validate | Normalization (trim, lowercase, strip protocols) with clear error messages for invalid entries |
| 3. Check | Per-domain progress indicators as DNS and RDAP queries complete |
| 4. Review | Results table with status badges, sortable columns, and filter controls |
| 5. Drill-in | Evidence panel with DNS/RDAP data, heuristics, and quick actions |
| 6. Shortlist | Curated list of favorites with notes, persisted in localStorage |
| 7. Export | One-click export as Markdown or CSV for sharing and decision-making |
Architecture
A pnpm monorepo with shared TypeScript types, a React SPA frontend, a Hono serverless API, and fully Terraform-managed AWS infrastructure — all running within free tier.
Monorepo structure
- packages/shared: TypeScript interfaces shared between frontend and backend
- frontend/: React 19 SPA with Vite, Tailwind CSS, dark/light theme
- backend/: Hono API with DNS/RDAP services, DynamoDB caching, rate limiting
- infra/: Terraform modules for API, database, frontend, DNS, and monitoring
AWS infrastructure
- Lambda: Hono API bundled with esbuild; Node 22 runtime
- API Gateway: HTTP API with CORS and throttling
- DynamoDB: Result caching with 15-min TTL per domain
- S3 + CloudFront: SPA hosting with global CDN and managed SSL
- CloudWatch: Alarms on error rates, P95 latency, and DynamoDB throttles
CI/CD pipeline
GitHub Actions runs lint, type-check, test, and bundle size check (<150 KB gzipped) on every PR. On merge to main: build all packages, esbuild Lambda bundle, Terraform plan/apply, S3 sync, CloudFront invalidation — zero-downtime deployment with GitHub OIDC authentication (no long-lived credentials).
Outcomes
Delivered capabilities
- Batch domain checking with two input modes (full domains or base + TLD combinations)
- Three-state availability model with DNS and RDAP evidence
- Drill-in panel with raw records, heuristics, and quick actions
- Shortlist with localStorage persistence and Markdown/CSV export
- Public versioned API ready for LLM and AI agent integrations
- Terraform-managed AWS infrastructure with CloudWatch monitoring
- Dark/light theme with system preference detection
- CI/CD with bundle size gates, OIDC auth, and zero-downtime deploys
Building serverless tools?
Domain Triage demonstrates full-stack serverless architecture, TypeScript monorepo discipline, evidence-driven UX, and cost-optimized infrastructure. If you need someone who can ship production-grade tools on a lean budget, let's talk.