Skip to main content
Migrating from Render to AWS gives you more control over infrastructure, predictable pricing at scale, and access to the full AWS ecosystem. LocalOps makes this migration seamless by providing the same developer experience you’re used to on Render.
White-glove migration: Our engineers will migrate your Render app to AWS. Schedule a migration call and we’ll handle everything for you.

​
What you get after migration

  • Same developer experience: Push to deploy, just like Render
  • Predictable costs: No surprise bills from auto-scaling—AWS pricing you control
  • Full AWS access: Use any AWS service (RDS, ElastiCache, S3, SQS, etc.)
  • Production-ready: Auto-scaling, auto-healing, monitoring, and CI/CD out of the box
  • Built-in observability: Open-source stack with Prometheus, Loki, and Grafana—no extra cost
  • No vendor lock-in: Your code runs on standard Kubernetes in your own AWS account

​
Migration overview

Set up LocalOps environment

Connect your AWS account and create a new environment for your app.

Deploy your application

Connect your GitHub repo and deploy your app to LocalOps.

Migrate Postgres database

Export your Render Postgres data and import it into Amazon RDS.

Update DNS and go live

Point your domain to the new environment and verify everything works.
Need help? Schedule a migration call and our engineers will assist you through the entire process.

​
Step 1: Set up LocalOps environment

Before migrating, you need a LocalOps environment running on AWS.

Create LocalOps account

Sign up for LocalOps if you haven’t already.

Connect AWS account

Follow the AWS connection guide to connect your AWS account.

Create environment

Create a new environment (e.g., production) in your preferred AWS region. See Create new environment.

Create service

Create a new service and connect your GitHub repository. See Create new service.
Once your environment is ready, note down the VPC ID and Private Subnet IDs from the environment overview page. You’ll need these to create your RDS database.

​
Step 2: Migrate Render Postgres to Amazon RDS

​
2.1 Create a backup of your Render Postgres database

Render provides external connection strings for Postgres databases. Use pg_dump to create a backup: 
# Get your external connection string from Render dashboard
# Dashboard > Your Database > Connections > External Connection String

# Create a backup using pg_dump
pg_dump "your-render-external-connection-string" \
  --format=custom \
  --no-owner \
  --no-acl \
  --file=render_backup.dump
Alternatively, you can create a backup from the Render dashboard:
  1. Navigate to your Postgres database in the Render dashboard
  2. Go to the Backups tab
  3. Click Create Backup to create a manual backup
  4. Download the backup file
For large databases, the backup and restore process may take significant time. Plan for a maintenance window if you need zero data loss during migration.

​
2.2 Create RDS database in your LocalOps environment VPC

You can either use the declarative ops.json approach (recommended) or create the database manually. Add an ops.json file to the root of your repository: 
{
  "dependencies": {
    "rds": {
      "instances": [
        {
          "id": "main-db",
          "prefix": "myapp",
          "engine": "postgres",
          "version": "16.4",
          "storage_gb": 20,
          "instance_type": "db.t4g.small",
          "publicly_accessible": false,
          "exports": {
            "DATABASE_HOST": "$address",
            "DATABASE_NAME": "$dbName",
            "DATABASE_USER": "$username",
            "DATABASE_PASSWORD_ARN": "$passwordArn"
          }
        }
      ]
    }
  }
}
Deploy your service to provision the RDS instance automatically. See RDS documentation for all configuration options.

​
Option B: Manual RDS creation

If you prefer to create the database manually:
  1. Login to AWS Console in the same region as your LocalOps environment
  2. Create a DB Subnet Group:
    • Navigate to RDS > Subnet groups > Create DB subnet group
    • Select the VPC ID from your LocalOps environment
    • Add the private subnet IDs from your LocalOps environment
    • Save the subnet group
  3. Create RDS Instance:
    • Navigate to RDS > Create database
    • Choose PostgreSQL and select the same major version as your Render database
    • Select the DB subnet group you created
    • Configure instance size (start with db.t4g.small for small apps)
    • Set Publicly accessible to No
    • Create or select a security group that allows inbound traffic on port 5432 from 10.0.0.0/16 (your VPC CIDR)
  4. Record connection details: Note down the endpoint, username, and password

​
2.3 Restore backup to Amazon RDS

To restore your Render backup to RDS, you need a machine that can access both the backup file and the RDS instance.

​
Option 1: Use an EC2 instance in the same VPC

# Launch a small EC2 instance in your LocalOps VPC
# SSH into the instance and install PostgreSQL client

sudo dnf install postgresql16 -y  # Amazon Linux 2023

# Upload your backup file to the EC2 instance
scp render_backup.dump ec2-user@your-ec2-ip:~/

# Restore the backup to RDS
pg_restore --verbose --no-owner --no-acl \
  -h your-rds-endpoint.rds.amazonaws.com \
  -U your-db-username \
  -d your-database-name \
  render_backup.dump

​
Option 2: Use AWS Database Migration Service (DMS)

For larger databases or if you need continuous replication during migration, use AWS DMS.

​
2.4 Configure database credentials in LocalOps

If you manually created the RDS instance, add the database credentials as secrets in your LocalOps service:
  1. Navigate to your service in the LocalOps console
  2. Go to Settings > Secrets
  3. Add the following secrets:
DATABASE_HOST=your-rds-endpoint.rds.amazonaws.com
DATABASE_NAME=your-database-name
DATABASE_USER=your-db-username
DATABASE_PASSWORD=your-db-password
See Secrets documentation for more details.

​
Step 3: Migrate environment variables

Export your environment variables from Render and add them to LocalOps:
  1. In Render dashboard, go to your service > Environment
  2. Copy each environment variable
  3. In LocalOps console, navigate to your service > Settings > Secrets
  4. Add each variable as a secret
For environment-specific variables, LocalOps lets you configure different values per environment (test, staging, production) from a single service configuration.

​
Step 4: Update your application

If your application uses DATABASE_URL (Render’s default), update it to use individual environment variables: 
// Before (Render)
const connectionString = process.env.DATABASE_URL;

// After (LocalOps)
const connectionString = `postgresql://${process.env.DATABASE_USER}:${password}@${process.env.DATABASE_HOST}/${process.env.DATABASE_NAME}`;
If you used ops.json to create RDS, the password is stored in AWS Secrets Manager. Use the AWS SDK to retrieve it using the DATABASE_PASSWORD_ARN environment variable.

​
Step 5: Deploy and verify

  1. Push your changes to trigger a deployment
  2. Check logs in the LocalOps console to verify the application starts correctly
  3. Test your application endpoints
  4. Update your DNS to point to the new LocalOps environment
See Custom domain setup for DNS configuration.

​
Built-in observability

Every LocalOps environment comes with a fully integrated open-source observability stack—no paid add-ons required.

​
Prometheus + Grafana for metrics

Prometheus automatically collects CPU, memory, disk, and network metrics from every node running your application. View and analyze metrics through pre-built Grafana dashboards, accessible from the Monitoring tab in your environment. You can filter and group metrics by:
  • Node
  • Pod
  • Deployment
  • Service
  • Namespace

​
Loki + Grafana for logs

Loki automatically collects all logs from STDOUT and STDERR across your services. No log drain configuration needed—just print to console and your logs are captured. Access logs through the same Grafana dashboard, with powerful filtering by Kubernetes namespace, deployment, or custom labels.

​
Custom dashboards

Each environment gets its own Grafana instance with pre-built dashboards for infrastructure monitoring. You can create custom dashboards to visualize application-specific metrics and logs.
Learn more about logs, metrics, and alerts.

​
Migrating other Render services

Render ServiceLocalOps Equivalent
Web ServiceWeb service
Background WorkerWorkers
Cron JobCron jobs
Private ServiceInternal service
Render PostgresAmazon RDS
Render RedisAmazon ElastiCache

​
Get help with your migration

White-glove migration: Don’t want to do this yourself? Our engineers will migrate your entire Render setup to AWS—including database migration, environment variables, and custom domains. Schedule a migration call now.
Have questions? Email us at [email protected].