Switch from Render to RaidFrame for flat pricing, built-in queues, and MCP integration.

Overview

Render and RaidFrame have similar developer experience — Docker support, managed databases, auto-deploys from GitHub. The migration is quick. The gains: flat pricing (no usage surprises), built-in queues and storage, database branching, MCP/AI integration, and traffic mirroring.

Step 1: Install the CLI

curl -fsSL https://get.raidframe.com | sh
rf auth login

Step 2: Export from Render

Environment Variables

In the Render dashboard, go to your service → Environment → copy all variables. Or use their API:

# Export Render env vars (via Render API)
curl -s -H "Authorization: Bearer $RENDER_TOKEN" \
  "https://api.render.com/v1/services/$SERVICE_ID/env-vars" | \
  jq -r '.[] | "\(.key)=\(.value)"' > .env

# Import to RaidFrame
rf env push

Database

# Get Render Postgres connection string from dashboard
# External Connection String → copy it

pg_dump $RENDER_POSTGRES_URL > backup.sql

rf add postgres
rf db import main backup.sql

Step 3: Convert Configuration

render.yaml → raidframe.yaml

# Render (render.yaml)
services:
  - type: web
    name: api
    runtime: docker
    dockerfilePath: ./Dockerfile
    envVars:
      - key: NODE_ENV
        value: production
    scaling:
      minInstances: 1
      maxInstances: 5
    healthCheckPath: /health

  - type: worker
    name: processor
    runtime: docker
    dockerfilePath: ./worker/Dockerfile

  - type: cron
    name: cleanup
    runtime: docker
    schedule: "0 3 * * *"
    dockerCommand: node scripts/cleanup.js

databases:
  - name: mydb
    plan: standard

redis:
  - name: cache
    plan: standard

Becomes:

# RaidFrame (raidframe.yaml)
services:
  api:
    type: web
    build:
      dockerfile: Dockerfile
    port: 3000
    health_check:
      path: /health
    scaling:
      min: 1
      max: 5

  processor:
    type: worker
    build:
      context: ./worker

  cleanup:
    type: cron
    schedule: "0 3 * * *"
    command: node scripts/cleanup.js

databases:
  main:
    engine: postgres
    plan: standard

  cache:
    engine: redis
    plan: standard

env:
  shared:
    NODE_ENV: production

Step 4: Deploy

rf deploy

Step 5: Move Domain

rf domains add myapp.com

Update DNS from Render's CNAME to RaidFrame's.

Render → RaidFrame Mapping

Render	RaidFrame
`render.yaml`	`raidframe.yaml`
Web Service	`type: web`
Private Service	`type: web` (private by default on internal network)
Background Worker	`type: worker`
Cron Job	`type: cron`
Render Postgres	`rf add postgres`
Render Redis	`rf add redis`
Render Dashboard	`rf` CLI + dashboard
Blueprint deploys	`rf deploy`
Preview Environments	Automatic per PR
Auto-deploy from Git	Automatic from `main`

What You Gain

Feature	Render	RaidFrame
Pricing	Usage-based, per-seat ($19/seat)	Flat per-service
Free tier spin-down	15-min idle → sleep	Configurable (or always-on)
Job queues	Not built-in	Built-in with retry + dead-letter
Object storage	Not built-in	S3-compatible, built-in
Email	Not built-in	Built-in transactional email
Search	Not built-in	Managed full-text search
Database branching	Not available	Fork, test, merge
Traffic mirroring	Not available	Mirror prod → staging
Chaos engineering	Not available	Built-in resilience testing
MCP/AI integration	Not available	Manage infra from AI assistants
VPN tunnel	Not available	WireGuard mesh
SSH into containers	Paid plans only	All plans
Canary deployments	Not available	Gradual rollout with auto-rollback
Cost intelligence	Basic billing	Forecasting + right-sizing

Common Migration Issues

Render Disk

If you're using Render's persistent disk, move files to RaidFrame object storage:

rf add storage
# Download from your Render service, upload to storage

Render Private Services

Render's "Private Services" (no public URL, internal only) map to RaidFrame worker services. Internal communication uses service.internal hostnames automatically.

Build Command

If you specified a custom build command in Render, add it to your Dockerfile or raidframe.yaml:

services:
  web:
    build:
      dockerfile: Dockerfile
      args:
        BUILD_CMD: "npm run build"

Auto-Deploy Branch

Render auto-deploys from a specific branch. Set the same on RaidFrame:

deploy:
  production:
    branch: main
    auto: true

Migrate from Render