5. Comparativa de Plataformas: Render vs Railway vs Fly.io

# platform_evaluation.py

criteria = {
    "Coste mensual": 25,
    "Developer experience": 20,
    "Tiempo de deploy": 15,
    "Soporte AI (timeout, RAM)": 20,
    "Escalabilidad futura": 20,
}

scores = {
    "Render": {
        "Coste mensual": (3, "$21/mes — predecible pero no el más barato"),
        "Developer experience": (3, "Dashboard simple, no CLI"),
        "Tiempo de deploy": (4, "Git push → auto deploy"),
        "Soporte AI (timeout, RAM)": (2, "30s timeout es limitante"),
        "Escalabilidad futura": (3, "Horizontal scaling, pero single region"),
    },
    "Railway": {
        "Coste mensual": (3, "$25-30/mes — flexible pero menos predecible"),
        "Developer experience": (5, "CLI excelente, preview envs, add-ons"),
        "Tiempo de deploy": (5, "railway up — el más rápido"),
        "Soporte AI (timeout, RAM)": (4, "5 min timeout, hasta 32 GB RAM"),
        "Escalabilidad futura": (3, "Auto-scaling, pero single region"),
    },
    "Fly.io": {
        "Coste mensual": (4, "$10-15/mes — el más barato"),
        "Developer experience": (3, "CLI potente pero más setup inicial"),
        "Tiempo de deploy": (3, "flyctl deploy — medio"),
        "Soporte AI (timeout, RAM)": (4, "Timeout configurable, WS nativo"),
        "Escalabilidad futura": (5, "Multi-region nativo, edge"),
    },
}

print("=== Evaluación de Plataformas ===\n")
print(f"{'Criterio':<30} {'Peso':>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"\nMáximo posible: {max_possible}")
winner = max(totals, key=totals.get)
print(f"Ganador: {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": "¿Qué es 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,    # Incluido en uso
        "redis": 0,         # Incluido en uso
        "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 si <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"=== Proyección de Costes a {MONTHS} Meses ===\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}/mes")
    print(f"  {'TOTAL mensual':<20} ${monthly['total']:.2f}/mes")
    print(f"  {'TOTAL ' + str(MONTHS) + ' meses':<20} ${monthly['total'] * MONTHS:.2f}")
    print()

## Output típico

--- Render ---
  compute              $7.00/mes
  postgresql           $7.00/mes
  redis                $7.00/mes
  openai_api           $180.00/mes
  TOTAL mensual        $201.00/mes
  TOTAL 6 meses        $1206.00

--- Railway ---
  base                 $5.00/mes
  compute              $25.28/mes
  openai_api           $180.00/mes
  TOTAL mensual        $210.28/mes
  TOTAL 6 meses        $1261.68

--- Fly.io ---
  compute_vm           $1.94/mes
  ram_extra            $4.46/mes
  postgresql           $1.94/mes
  volume               $0.15/mes
  openai_api           $180.00/mes
  TOTAL mensual        $188.49/mes
  TOTAL 6 meses        $1130.94

Nota: El coste de OpenAI API domina en todos los casos.
La diferencia entre plataformas (~$20/mes) es marginal
comparada con $180/mes de API.

# Limitaciones para DocuSearch AI (RAG + GPT-4o-mini)

## Render
1. **Timeout 30s:** Mi endpoint /ask tarda ~2-3s normalmente, pero queries
   complejas con mucho contexto RAG pueden tardar 10-15s. Si agrego
   streaming, podría tocar los 30s fácilmente.
   → Workaround: Implementar SSE streaming obligatorio para /ask

2. **No CLI:** Para hotfixes rápidos, necesito ir al dashboard.
   Deploy es por git push, lo cual está bien, pero gestionar variables
   y ver logs requiere el browser.
   → Workaround: Usar Render API con curl/scripts

3. **PostgreSQL Free: 97 días.** Si uso el free tier para desarrollo,
   pierdo datos cada ~3 meses.
   → Workaround: Starter ($7/mes) o exportar datos periódicamente

## Railway
1. **Pricing impredecible:** Con 3K requests/día, el coste varía según
   uso de CPU. Un spike de tráfico = factura inesperada.
   → Workaround: Configurar resource limits y alertas de billing

2. **Single region:** Mis usuarios están en Latinoamérica. Railway no me
   deja elegir región cercana (São Paulo no disponible directamente).
   → Workaround: Aceptar latencia extra o usar Fly.io para esos usuarios

3. **Trial $5 dura poco:** Para testing, los $5 se agotan en ~5-7 días
   con la app corriendo. Necesito Hobby ($5/mes) desde el día 1.
   → Workaround: Upgrade inmediato a Hobby

## Fly.io
1. **Volumes region-locked:** Si escalo a multi-region, cada región necesita
   su propio volume. No puedo compartir cache entre regiones.
   → Workaround: Usar Redis (Upstash) para cache compartido, volumes solo
     para datos locales

2. **Más setup inicial:** flyctl launch + fly.toml + secrets + deploy es
   más pasos que railway up.
   → Workaround: Scriptar el setup en un Makefile

3. **Shared CPU variable:** En shared, el rendimiento de CPU fluctúa.
   Embedding generation puede ser lenta en horas pico.
   → Workaround: Pre-generar embeddings offline, usar dedicated CPU ($31/mes)
     si el rendimiento es crítico