5. Platform Comparison: Render vs Railway vs Fly.io

# platform_evaluation.py

criteria = {
    "Monthly cost": 25,
    "Developer experience": 20,
    "Deploy time": 15,
    "AI support (timeout, RAM)": 20,
    "Future scalability": 20,
}

scores = {
    "Render": {
        "Monthly cost": (3, "$21/month — predictable but not the cheapest"),
        "Developer experience": (3, "Simple dashboard, no CLI"),
        "Deploy time": (4, "Git push → auto deploy"),
        "AI support (timeout, RAM)": (2, "30s timeout is limiting"),
        "Future scalability": (3, "Horizontal scaling, but single region"),
    },
    "Railway": {
        "Monthly cost": (3, "$25-30/month — flexible but less predictable"),
        "Developer experience": (5, "Excellent CLI, preview envs, add-ons"),
        "Deploy time": (5, "railway up — the fastest"),
        "AI support (timeout, RAM)": (4, "5 min timeout, up to 32 GB RAM"),
        "Future scalability": (3, "Auto-scaling, but single region"),
    },
    "Fly.io": {
        "Monthly cost": (4, "$10-15/month — the cheapest"),
        "Developer experience": (3, "Powerful CLI but more initial setup"),
        "Deploy time": (3, "flyctl deploy — medium"),
        "AI support (timeout, RAM)": (4, "Configurable timeout, native WS"),
        "Future scalability": (5, "Native multi-region, edge"),
    },
}

print("=== Platform Evaluation ===\n")
print(f"{'Criterion':<30} {'Weight':>4}  {'Render':>8} {'Railway':>8} {'Fly.io':>8}")
print("-" * 70)

totals = {"Render": 0, "Railway": 0, "Fly.io": 0}

for criterion, weight in criteria.items():
    print(f"{criterion:<30} {weight:>4}", end="")
    for platform in ["Render", "Railway", "Fly.io"]:
        score, _ = scores[platform][criterion]
        weighted = weight * score
        totals[platform] += weighted
        print(f"  {weighted:>6}", end="")
    print()

print("-" * 70)
print(f"{'TOTAL':<30} {sum(criteria.values()):>4}", end="")
for platform in ["Render", "Railway", "Fly.io"]:
    print(f"  {totals[platform]:>6}", end="")
print()

max_possible = sum(criteria.values()) * 5
print(f"\nMaximum possible: {max_possible}")
winner = max(totals, key=totals.get)
print(f"Winner: {winner} ({totals[winner]}/{max_possible})")

# benchmark_platforms.py
import time
import requests
import statistics
from concurrent.futures import ThreadPoolExecutor

PLATFORMS = {
    "Render": "https://docusearch-ai.onrender.com",
    "Railway": "https://docusearch-ai-production.up.railway.app",
    "Fly.io": "https://docusearch-ai-fly.fly.dev",
}

NUM_REQUESTS = 10


def measure_endpoint(platform: str, url: str, endpoint: str, payload=None) -> list:
    latencies = []
    for _ in range(NUM_REQUESTS):
        start = time.time()
        try:
            if payload:
                resp = requests.post(f"{url}{endpoint}", json=payload, timeout=30)
            else:
                resp = requests.get(f"{url}{endpoint}", timeout=30)
            elapsed = (time.time() - start) * 1000
            if resp.status_code == 200:
                latencies.append(elapsed)
        except Exception:
            latencies.append(30000)
        time.sleep(0.5)
    return latencies


print("=== Health Check Latency ===\n")
print(f"{'Platform':<12} {'Avg':>8} {'Median':>8} {'P95':>8} {'Min':>8} {'Max':>8}")
print("-" * 56)

for platform, url in PLATFORMS.items():
    lats = measure_endpoint(platform, url, "/health")
    if lats:
        avg = statistics.mean(lats)
        med = statistics.median(lats)
        p95 = sorted(lats)[int(len(lats) * 0.95)]
        print(f"{platform:<12} {avg:>7.0f}ms {med:>7.0f}ms {p95:>7.0f}ms "
              f"{min(lats):>7.0f}ms {max(lats):>7.0f}ms")

print("\n=== Inference Latency ===\n")
print(f"{'Platform':<12} {'Avg':>8} {'Median':>8} {'P95':>8}")
print("-" * 40)

payload = {"question": "What is Python?", "max_tokens": 50}
for platform, url in PLATFORMS.items():
    lats = measure_endpoint(platform, url, "/ask", payload)
    if lats:
        avg = statistics.mean(lats)
        med = statistics.median(lats)
        p95 = sorted(lats)[int(len(lats) * 0.95)]
        print(f"{platform:<12} {avg:>7.0f}ms {med:>7.0f}ms {p95:>7.0f}ms")

# cost_projection.py
MONTHS = 6

app_config = {
    "daily_requests": 3000,
    "avg_openai_cost_per_request": 0.002,
    "needs_postgresql": True,
    "needs_redis": True,
    "ram_gb": 1,
}


def render_cost(config: dict) -> dict:
    monthly = {
        "compute": 7,       # Starter plan
        "postgresql": 7,    # Starter plan
        "redis": 7,         # Starter plan
        "openai_api": config["daily_requests"] * 30 * config["avg_openai_cost_per_request"],
    }
    monthly["total"] = sum(monthly.values())
    return {k: round(v, 2) for k, v in monthly.items()}


def railway_cost(config: dict) -> dict:
    hours_per_month = 730
    vcpu_cost = 0.02778 * hours_per_month
    ram_cost = config["ram_gb"] * 0.01388 * hours_per_month
    hobby_base = 5
    hobby_credit = 5
    compute_net = max(0, vcpu_cost + ram_cost - hobby_credit)

    monthly = {
        "base": hobby_base,
        "compute": round(compute_net, 2),
        "postgresql": 0,    # Included in usage
        "redis": 0,         # Included in usage
        "openai_api": config["daily_requests"] * 30 * config["avg_openai_cost_per_request"],
    }
    monthly["total"] = sum(monthly.values())
    return {k: round(v, 2) for k, v in monthly.items()}


def flyio_cost(config: dict) -> dict:
    monthly = {
        "compute_vm": 1.94,                      # shared-cpu-1x (free if <3 VMs)
        "ram_extra": max(0, (config["ram_gb"] - 0.256)) * 6,
        "postgresql": 1.94,                       # Fly Postgres VM
        "redis": 0,                               # Upstash free tier
        "volume": 0.15,                           # 1 GB
        "openai_api": config["daily_requests"] * 30 * config["avg_openai_cost_per_request"],
    }
    monthly["total"] = sum(monthly.values())
    return {k: round(v, 2) for k, v in monthly.items()}


print(f"=== {MONTHS}-Month Cost Projection ===\n")

for name, calc_fn in [("Render", render_cost), ("Railway", railway_cost), ("Fly.io", flyio_cost)]:
    monthly = calc_fn(app_config)
    print(f"--- {name} ---")
    for k, v in monthly.items():
        if k != "total":
            print(f"  {k:<20} ${v:.2f}/month")
    print(f"  {'TOTAL monthly':<20} ${monthly['total']:.2f}/month")
    print(f"  {'TOTAL ' + str(MONTHS) + ' months':<20} ${monthly['total'] * MONTHS:.2f}")
    print()

## Typical output

--- Render ---
  compute              $7.00/month
  postgresql           $7.00/month
  redis                $7.00/month
  openai_api           $180.00/month
  TOTAL monthly        $201.00/month
  TOTAL 6 months       $1206.00

--- Railway ---
  base                 $5.00/month
  compute              $25.41/month
  openai_api           $180.00/month
  TOTAL monthly        $210.41/month
  TOTAL 6 months       $1262.46

--- Fly.io ---
  compute_vm           $1.94/month
  ram_extra            $4.46/month
  postgresql           $1.94/month
  volume               $0.15/month
  openai_api           $180.00/month
  TOTAL monthly        $188.49/month
  TOTAL 6 months       $1130.94

Note: The OpenAI API cost dominates in every case.
The difference between platforms (~$20/month) is marginal
compared to $180/month of API cost.

# Limitations for DocuSearch AI (RAG + GPT-4o-mini)

## Render
1. **30s timeout:** My /ask endpoint usually takes ~2-3s, but complex
   queries with a lot of RAG context can take 10-15s. If I add
   streaming, I could easily hit 30s.
   → Workaround: Implement mandatory SSE streaming for /ask

2. **No CLI:** For quick hotfixes, I need to go to the dashboard.
   Deploy is via git push, which is fine, but managing variables
   and viewing logs requires the browser.
   → Workaround: Use the Render API with curl/scripts

3. **PostgreSQL Free: 97 days.** If I use the free tier for development,
   I lose data every ~3 months.
   → Workaround: Starter ($7/month) or export data periodically

## Railway
1. **Unpredictable pricing:** With 3K requests/day, the cost varies by
   CPU usage. A traffic spike = an unexpected bill.
   → Workaround: Configure resource limits and billing alerts

2. **Single region:** My users are in Latin America. Railway doesn't
   let me choose a nearby region (São Paulo not directly available).
   → Workaround: Accept the extra latency or use Fly.io for those users

3. **Trial $5 lasts a short time:** For testing, the $5 runs out in ~5-7 days
   with the app running. I need Hobby ($5/month) from day 1.
   → Workaround: Immediate upgrade to Hobby

## Fly.io
1. **Region-locked volumes:** If I scale to multi-region, each region needs
   its own volume. I can't share cache across regions.
   → Workaround: Use Redis (Upstash) for shared cache, volumes only
     for local data

2. **More initial setup:** flyctl launch + fly.toml + secrets + deploy is
   more steps than railway up.
   → Workaround: Script the setup in a Makefile

3. **Variable shared CPU:** On shared, CPU performance fluctuates.
   Embedding generation can be slow during peak hours.
   → Workaround: Pre-generate embeddings offline, use dedicated CPU ($31/month)
     if performance is critical