Sail JADA — Engineering Log

Technical work on sailjada.com and the JADA booking systems

Domain Availability Research at Scale: Building a Franchise Validation System for Port Cities

Ticket t-f860fe03 presented an interesting infrastructure challenge: validate the commercial viability of a "Queen of [City]" franchise concept by checking domain availability across 130+ port cities worldwide. This required moving beyond traditional whois tooling to implement a robust, rate-limit-resistant domain registry checker using RDAP protocol.

The Problem: Franchise Domain Validation

The business case was straightforward but data-intensive: for each of 130+ globally distributed port cities, determine whether the domain queenof[city].com is available for registration. This would inform franchise expansion strategy. However, the naive approach—hammering the WHOIS registry with 130+ sequential queries—proved immediately problematic due to Verisign rate limiting.

Technical Implementation: From WHOIS to RDAP

Initial Approach (Failed): The first iteration used the Python whois library against the authoritative WHOIS registry. While conceptually sound, real-world results showed systematic failures:

  • 130 queries returned "unknown" status (registry throttling by source IP)
  • Even control domain queenofsandiego.com (known to be registered) returned unknown
  • Rate limiting kicked in after ~20-30 queries

Solution: RDAP Protocol: Rather than fight rate limiting, we pivoted to RDAP (Registration Data Access Protocol), Verisverden's modern HTTP/JSON registry endpoint. Key advantages:

  • HTTP-based with sensible rate limits (~10-20 req/sec per source)
  • RESTful semantics: 404 = available, 200 = registered
  • JSON responses eliminate parsing fragility
  • Less aggressively throttled than legacy WHOIS

Implementation Details

Created two Python checker modules in /Users/cb/icloud-jada-ops/ticket-runner/:

File 1: check_queenof_domains.py 


# Core RDAP domain checker
# Queries: https://domain-services.icann.org/rdap/domain/{domain}
# Response codes:
#   404 → domain available (no registration record)
#   200 → domain registered (active record present)
#   429 → rate limited (backoff with exponential jitter)

import requests
import time
from typing import Dict, List

def check_domain_rdap(domain: str, max_retries: int = 3) -> str:
    """
    Check domain availability via ICANN RDAP endpoint.
    Returns: 'available', 'registered', or 'unknown'
    """
    url = f"https://domain-services.icann.org/rdap/domain/{domain}"
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, timeout=10)
            
            if response.status_code == 404:
                return 'available'
            elif response.status_code == 200:
                return 'registered'
            elif response.status_code == 429:
                # Rate limited; exponential backoff with jitter
                backoff = (2 ** attempt) + random.uniform(0, 1)
                time.sleep(backoff)
                continue
            else:
                return 'unknown'
                
        except requests.Timeout:
            return 'unknown'
    
    return 'unknown'

def check_batch_domains(domains: List[str]) -> Dict[str, str]:
    """Check multiple domains with thoughtful rate limiting."""
    results = {}
    for i, domain in enumerate(domains):
        results[domain] = check_domain_rdap(domain)
        # Respect rate limits: ~5 req/sec
        time.sleep(0.2)
        if (i + 1) % 20 == 0:
            print(f"Progress: {i+1}/{len(domains)}")
    return results

File 2: check_queenof_dream.py

Extended checker that validates against curated port-city datasets and outputs markdown reports suitable for ticket attachment.

Data Collection and Processing

Port cities were sourced from a curated geographic dataset (130+ cities across 6 continents). The domain normalization pipeline:

  • Strip whitespace and punctuation
  • Convert to lowercase
  • Format as queenof{city}.com
  • Skip cities with names >20 chars (domain length limits)

Results were written to two markdown reports:

  • /Users/cb/icloud-jada-ops/QUEEN-OF-FRANCHISE-DOMAINS-2026-06-04.md — Full domain inventory
  • /Users/cb/icloud-jada-ops/QUEEN-OF-DREAM-DESTINATIONS-2026-06-04.md — Curated "best opportunity" subset

Key Findings and Validation

RDAP validation proved reliable:

  • 0 "unknown" results (vs. 130 with WHOIS)
  • Control domain test passed: queenofsandiego.com correctly identified as "registered"
  • Available domains found: 47 out of 130 checked domains immediately available for registration
  • Execution time: ~25 seconds for full batch (rate-limited at ~5 req/sec)

Architecture Decisions

Why RDAP over alternatives:

  • vs. WHOIS: HTTP-based, modern rate limiting, JSON parsing, faster
  • vs. third-party APIs: No credentials required, ICANN authority, no quota costs
  • vs. bulk registry queries: Real-time results, accurate availability status

Exponential backoff with jitter: When encountering 429 responses, we use the formula backoff = 2^attempt + random(0,1) rather than linear backoff. This prevents thundering-herd effects if multiple instances run concurrently and allows fair sharing of rate-limit quota.

Markdown-based reporting: Rather than database storage, results go directly to markdown files attachable to tickets. This provides human-readable summaries while maintaining machine-parseable structure for downstream tooling.

Deployment and Integration

Scripts are currently living in /Users/cb/icloud-jada-ops/ticket-runner/ and execute as one-off tools during ticket investigation. Future improvements would involve:

  • CI/CD integration for periodic re-checks (quarterly domain availability audits)
  • Lambda-based scheduled execution to monitor domain price/availability trends
  • Results storage in RDS for historical analysis and franchise opportunity scoring

What's Next

This foundation enables: