Hot Take: Why You Should Stop Using Heroku in 2026 – Use Render 2.0 and Kubernetes 1.36 for Better Scalability

// node-api-server.js - Production-ready Node.js 20 API for K8s 1.36 deployment
// Complies with Kubernetes container best practices: graceful shutdown, structured logs, health checks
const express = require('express');
const { createLogger, format, transports } = require('winston');
const promClient = require('prom-client');
const app = express();
const PORT = process.env.PORT || 3000;
const SHUTDOWN_TIMEOUT = 10000; // 10s grace period for K8s termination

// Structured logger with JSON output for log aggregation (Datadog, Grafana Loki)
const logger = createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: format.combine(
    format.timestamp({ format: 'ISO-8601' }),
    format.errors({ stack: true }),
    format.json()
  ),
  transports: [new transports.Console()]
});

// Prometheus metrics for K8s HPA and monitoring
const register = new promClient.Registry();
promClient.collectDefaultMetrics({ register });
const httpRequestDuration = new promClient.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  registers: [register]
});

// Middleware to track request duration
app.use((req, res, next) => {
  const end = httpRequestDuration.startTimer();
  res.on('finish', () => {
    end({ method: req.method, route: req.path, status_code: res.statusCode });
  });
  next();
});

// Health check endpoint for K8s liveness/readiness probes
app.get('/healthz', (req, res) => {
  // Add dependency checks here (DB, Redis, etc.) in production
  res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() });
});

// Main API endpoint
app.get('/api/v1/users', async (req, res, next) => {
  try {
    // Simulate DB fetch with timeout (replace with real DB client in production)
    const users = await fetchUsersFromDB();
    res.status(200).json({ users, count: users.length });
  } catch (err) {
    logger.error('Failed to fetch users', { error: err.message, stack: err.stack });
    res.status(500).json({ error: 'Internal server error' });
    next(err);
  }
});

// Mock DB fetch function with error simulation
async function fetchUsersFromDB() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Simulate 1% error rate for testing
      if (Math.random() < 0.01) {
        reject(new Error('DB connection timeout'));
      } else {
        resolve([
          { id: 1, name: 'Alice', email: 'alice@example.com' },
          { id: 2, name: 'Bob', email: 'bob@example.com' }
        ]);
      }
    }, 100);
  });
}

// Graceful shutdown handler for K8s termination signals
let server;
const shutdown = async () => {
  logger.info('Received shutdown signal, closing server...');
  if (server) {
    server.close(() => {
      logger.info('HTTP server closed');
      process.exit(0);
    });
    // Force shutdown after timeout
    setTimeout(() => {
      logger.error('Forcing shutdown after timeout');
      process.exit(1);
    }, SHUTDOWN_TIMEOUT);
  } else {
    process.exit(0);
  }
};

// Listen for K8s termination signals
process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);

// Start server
server = app.listen(PORT, () => {
  logger.info(`API server listening on port ${PORT}`, { env: process.env.NODE_ENV || 'development' });
});

// Global error handler
process.on('uncaughtException', (err) => {
  logger.error('Uncaught exception', { error: err.message, stack: err.stack });
  shutdown();
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled rejection', { reason: reason?.message, stack: reason?.stack });
  shutdown();
});

# k8s-deployment-1.36.yaml - Kubernetes 1.36 Deployment for Node.js API
# Uses HPA v3 (GA in K8s 1.36) with custom metrics for scaling
apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-api-deployment
  namespace: production
  labels:
    app: node-api
    version: 1.0.0
spec:
  replicas: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0 # Zero-downtime deployments
  selector:
    matchLabels:
      app: node-api
  template:
    metadata:
      labels:
        app: node-api
        version: 1.0.0
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "3000"
        prometheus.io/path: "/metrics"
    spec:
      containers:
      - name: node-api
        image: registry.example.com/node-api:v1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 3000
          name: http
        resources:
          requests:
            cpu: "250m"
            memory: "256Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        livenessProbe:
          httpGet:
            path: /healthz
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
          timeoutSeconds: 1
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /healthz
            port: 3000
          initialDelaySeconds: 3
          periodSeconds: 5
          timeoutSeconds: 1
          failureThreshold: 1
        env:
        - name: NODE_ENV
          value: "production"
        - name: LOG_LEVEL
          value: "info"
        - name: PORT
          value: "3000"
        securityContext:
          runAsNonRoot: true
          runAsUser: 1000
          readOnlyRootFilesystem: true
      terminationGracePeriodSeconds: 15 # Matches SHUTDOWN_TIMEOUT in app
      securityContext:
        fsGroup: 1000
---
# HorizontalPodAutoscaler v3 (GA in K8s 1.36)
apiVersion: autoscaling/v3
kind: HorizontalPodAutoscaler
metadata:
  name: node-api-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: node-api-deployment
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Pods
    pods:
      metric:
        name: http_request_duration_seconds_count
      target:
        type: AverageValue
        averageValue: "100" # Scale if >100 requests/sec per pod
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 30
      policies:
      - type: Percent
        value: 50
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60
---
# Service to expose the deployment
apiVersion: v1
kind: Service
metadata:
  name: node-api-service
  namespace: production
spec:
  selector:
    app: node-api
  ports:
  - port: 80
    targetPort: 3000
    protocol: TCP
  type: ClusterIP

# heroku-to-render-migrator.py - Migrate Heroku apps to Render 2.0 programmatically
# Uses Heroku API v3 and Render API v2, requires HEROKU_API_KEY and RENDER_API_KEY env vars
import os
import requests
import json
import time
from typing import Dict, List, Optional

# Configure logging
import logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

HEROKU_API_BASE = "https://api.heroku.com"
RENDER_API_BASE = "https://api.render.com/v2"
HEROKU_HEADERS = {
    "Accept": "application/vnd.heroku+json; version=3",
    "Authorization": f"Bearer {os.getenv('HEROKU_API_KEY')}"
}
RENDER_HEADERS = {
    "Accept": "application/json",
    "Authorization": f"Bearer {os.getenv('RENDER_API_KEY')}"
}

class MigrationError(Exception):
    """Custom exception for migration failures"""
    pass

def validate_env_vars() -> None:
    """Check required environment variables are set"""
    required_vars = ["HEROKU_API_KEY", "RENDER_API_KEY", "HEROKU_APP_NAME", "RENDER_OWNER_ID"]
    missing = [var for var in required_vars if not os.getenv(var)]
    if missing:
        raise MigrationError(f"Missing required env vars: {', '.join(missing)}")

def get_heroku_app_config(app_name: str) -> Dict:
    """Fetch Heroku app config vars and dyno info"""
    logger.info(f"Fetching config for Heroku app: {app_name}")
    try:
        # Get app details
        app_resp = requests.get(f"{HEROKU_API_BASE}/apps/{app_name}", headers=HEROKU_HEADERS)
        app_resp.raise_for_status()
        app = app_resp.json()

        # Get config vars
        config_resp = requests.get(f"{HEROKU_API_BASE}/apps/{app_name}/config-vars", headers=HEROKU_HEADERS)
        config_resp.raise_for_status()
        config_vars = config_resp.json()

        # Get dyno size and quantity
        dyno_resp = requests.get(f"{HEROKU_API_BASE}/apps/{app_name}/formation", headers=HEROKU_HEADERS)
        dyno_resp.raise_for_status()
        dynos = dyno_resp.json()
        web_dyno = next((d for d in dynos if d["type"] == "web"), None)

        return {
            "name": app["name"],
            "stack": app["stack"]["name"],
            "config_vars": config_vars,
            "dyno_size": web_dyno["size"] if web_dyno else "basic",
            "dyno_quantity": web_dyno["quantity"] if web_dyno else 1
        }
    except requests.exceptions.RequestException as e:
        raise MigrationError(f"Failed to fetch Heroku app config: {str(e)}")

def create_render_service(heroku_config: Dict) -> Dict:
    """Create a Render 2.0 web service matching Heroku app config"""
    logger.info(f"Creating Render service for {heroku_config['name']}")
    # Map Heroku dyno sizes to Render instance types (Render 2.0 sizing)
    dyno_to_render = {
        "basic": "starter",
        "standard-1x": "standard",
        "standard-2x": "pro",
        "performance-m": "pro-plus",
        "performance-l": "ultra"
    }
    render_instance = dyno_to_render.get(heroku_config["dyno_size"], "starter")

    payload = {
        "type": "web_service",
        "name": heroku_config["name"],
        "ownerId": os.getenv("RENDER_OWNER_ID"),
        "repo": os.getenv("GIT_REPO_URL"), # Assumes same repo as Heroku app
        "branch": "main",
        "runtime": "node" if "node" in heroku_config["stack"] else "python",
        "instanceType": render_instance,
        "numInstances": heroku_config["dyno_quantity"],
        "envVars": [
            {"key": k, "value": v} for k, v in heroku_config["config_vars"].items()
        ],
        "healthCheckPath": "/healthz",
        "autoDeploy": "yes"
    }

    try:
        resp = requests.post(f"{RENDER_API_BASE}/services", headers=RENDER_HEADERS, json=payload)
        resp.raise_for_status()
        service = resp.json()
        logger.info(f"Created Render service: {service['id']}")
        return service
    except requests.exceptions.RequestException as e:
        raise MigrationError(f"Failed to create Render service: {str(e)}")

def wait_for_render_deploy(service_id: str) -> None:
    """Poll Render API until deployment completes"""
    logger.info(f"Waiting for Render service {service_id} to deploy...")
    timeout = 300 # 5 minute timeout
    start = time.time()
    while time.time() - start < timeout:
        try:
            resp = requests.get(f"{RENDER_API_BASE}/services/{service_id}/deploys?limit=1", headers=RENDER_HEADERS)
            resp.raise_for_status()
            deploy = resp.json()[0]
            if deploy["status"] == "live":
                logger.info(f"Deploy {deploy['id']} is live")
                return
            elif deploy["status"] == "failed":
                raise MigrationError(f"Deploy failed: {deploy.get('failureReason', 'Unknown')}")
            time.sleep(10)
        except requests.exceptions.RequestException as e:
            logger.warning(f"Failed to check deploy status: {str(e)}")
            time.sleep(10)
    raise MigrationError("Deploy timed out after 5 minutes")

if __name__ == "__main__":
    try:
        validate_env_vars()
        heroku_app = get_heroku_app_config(os.getenv("HEROKU_APP_NAME"))
        render_service = create_render_service(heroku_app)
        wait_for_render_deploy(render_service["id"])
        logger.info(f"Migration complete! Render service URL: {render_service['url']}")
    except MigrationError as e:
        logger.error(f"Migration failed: {str(e)}")
        exit(1)
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        exit(1)

# render.yaml - Minimal Render 2.0 Blueprint for Node.js app
services:
  - type: web
    name: my-app-web
    runtime: node
    buildCommand: npm run build
    startCommand: npm start
    instanceType: standard
    numInstances: 2
    envVars:
      - key: NODE_ENV
        value: production
      - key: DB_URL
        fromDatabase:
          name: my-app-db
          property: connectionString
databases:
  - name: my-app-db
    databaseName: production
    user: admin
    plan: free # Upgrade to postgres-16 for production

# HPA v3 snippet for request rate scaling
metrics:
- type: Pods
  pods:
    metric:
      name: http_request_duration_seconds_count
    target:
      type: AverageValue
      averageValue: "150" # 150 req/s per pod
behavior:
  scaleUp:
    stabilizationWindowSeconds: 30
    policies:
    - type: Percent
      value: 50
      periodSeconds: 60

// k6-load-test.js - Basic load test for API migration benchmarking
import http from 'k6/http';
import { sleep, check } from 'k6';

export const options = {
  stages: [
    { duration: '5m', target: 1000 }, // Ramp to 1k users
    { duration: '10m', target: 1000 }, // Sustain peak
    { duration: '5m', target: 0 }, // Ramp down
  ],
};

export default function () {
  const res = http.get('https://your-app-url.com/api/v1/users');
  check(res, { 'status was 200': (r) => r.status == 200 });
  sleep(1);
}