Migrate from Render to Laravel Cloud
On Render, a Laravel app needs a Dockerfile, an nginx config, and separate services for queue workers and the scheduler. Laravel Cloud runs your app with the scheduler, email, managed queues and databases built in. This guide walks you through moving your Laravel application from Render to Cloud.
Why migrate from Render to Laravel Cloud?
No Dockerfile to maintain: Render has no native PHP runtime, so you have to build and maintain a Docker image. Cloud runs PHP natively, so you can connect your repo and deploy.
Managed MySQL and Postgres: Render offers managed Postgres only. MySQL runs as a private service you host yourself. Cloud runs both for you, with automated backups.
Queues and the scheduler built in: No separate worker or cron apps to build, configure, and pay for. Add a managed queue that scales with your jobs, and turn on the scheduler with one toggle.
Full-stack scale to zero: Compute, databases, and cache sleep when idle and wake together in under 500 ms on Flex compute. On Render, paid services run around the clock.
Autoscaling on real traffic: Cloud adds and removes replicas based on live traffic, CPU, and memory, on Growth and above.
Jobs finish during deploys: Managed queue workers get up to 90 seconds (Flex) or one hour (Pro) to finish the current job. Render's default is 30 seconds.
Spending limits with a hard cap: Get alerts at 50%, 80%, 90%, and 100%, and choose to pause compute at your limit.
Standard Laravel apps can migrate in as little as 30 minutes.
Want the full side-by-side? See Laravel Cloud vs. Render.
“We weren't necessarily surprised, but the simplicity of setting up an environment and deploying could not have been easier.”
Jesse Schoberg
Co-founder at DropInBlog
Prerequisites
- Access to your Render services and database
- Git repository connected to a supported provider (GitHub, GitLab, Bitbucket)
- Database credentials for your Render Postgres database, or shell access to your MySQL private service
- DNS management access for your domain
- A Laravel Cloud account
Render to Laravel Cloud: Migration steps
Set up Laravel Cloud account
Create your Cloud account and set up your organization. Have questions? Check our Laravel Cloud Quickstart documentation.
Create your new application
- From your Laravel Cloud dashboard, click + New application.
- Connect your Git provider (GitHub, GitLab, or Bitbucket).
- Select your repository and branch.
- Configure your environment settings:
- Choose PHP version from the list of supported versions.
- Set environment variables (see Prepare to migrate for what to copy and what to leave behind).
- Add any secrets your application needs.
Provision your new infrastructure
Create the resources your application needs:
Laravel MySQL or Serverless Postgres database
- In your environment's infrastructure canvas, Add a database.
- Choose Serverless Postgres if you use Render Postgres, or Laravel MySQL if you self-host MySQL on Render. AWS RDS databases for MySQL and Postgres are also available on Laravel Private Cloud.
- Select compute size based on your needs.
- Enable a public endpoint for migration (you can disable it after).
- Laravel Cloud automatically configures Laravel environment variables.
Laravel Valkey for cache and session storage
- Add Redis-compatible Laravel Valkey to your infrastructure canvas. This replaces Render Key Value. Fully managed AWS ElastiCache caches (both Valkey and Redis OSS) are also available in Laravel Private Cloud.
- Laravel Cloud automatically configures your environment variables.
Object storage (S3-compatible)
- Add Object storage if you use file uploads or a Render persistent disk.
- Install the package Laravel needs to use it: composer require league/flysystem-aws-s3-v3.
- Cloud injects FILESYSTEM_DISK and the bucket credentials for you.
Queues and scheduler
- Click Add compute, then Managed queue. This replaces your Render background worker.
- Click your App cluster in the infrastructure canvas and turn on the Scheduler toggle. This replaces your Render cron job.
You've now set up a new Laravel Cloud account and provisioned all necessary infrastructure. You can now migrate your Render application to Laravel Cloud.
Prepare to migrate
- Log into your Render dashboard.
- Get your Render database credentials:
- Postgres: open your database and click Connect (top right). Copy the External Database URL.
- MySQL private service: your MySQL user, password, and database name are in that service's Environment page. You'll export from inside the service, since private services can't be reached from the internet.
- Copy your environment variables:
- Open each service's Environment page, plus any linked Environment Groups.
- Copy your app-specific values (API keys, mail settings, APP_KEY, and so on) into Cloud.
- If you used a render.yaml Blueprint, copy the actual values. Blueprint-only settings like fromDatabase, fromService, and generateValue don't carry over.
- Leave these behind: DATABASE_URL, DB_URL, REDIS_URL, and any ASSET_URL that points to your onrender.com address. Cloud injects its own database and cache credentials, and a leftover database URL would point your app back at Render.
- Don't copy QUEUE_CONNECTION. Cloud sets QUEUE_CONNECTION=cloud for managed queues, and custom variables take priority over injected ones. If you use Horizon, keep your Redis queue settings instead (see the Code changes required section).
- Keep DB_CONNECTION (pgsql or mysql). Cloud doesn't list it among the variables it injects, and newer Laravel apps fall back to SQLite without it.
- If SESSION_DRIVER or CACHE_STORE is set to file, change it to database or redis. Cloud's filesystem resets on every deploy.
Migrate your database
With your new Laravel Cloud database provisioned and public endpoint enabled:
Finding your Laravel Cloud database credentials:
- Cloud dashboard → Environment → Database → View credentials
- Credentials are also injected as environment variables
Check your versions first. Run SELECT version(); on your Render database. New Render Postgres databases default to version 18, and Render's MySQL template runs MySQL 8.0. Use a pg_dump client at least as new as your Postgres server.
For Render Postgres
Export from Render
Render requires TLS for outside connections, so keep sslmode=require. If you've restricted access under Networking, add your IP to the allow list first.
Import to Laravel Cloud
# From your local machine
pg_restore \
--clean \
--no-owner \
--no-acl \
--if-exists \
--dbname="postgresql://cloud-db-username:cloud-db-password@cloud-db-host:cloud-db-port/cloud-db-database" \
"dump-file.bak"For MySQL on a Render private service
Render's MySQL runs as a private service, so you export from inside it, then copy the file to your machine.
Export from Render
Open the Shell tab on your MySQL service (or connect over SSH) and run:
# Inside your Render MySQL service
mysqldump \
--user="render-mysql-username" \
--password="render-mysql-password" \
--single-transaction \
--set-gtid-purged=OFF \
--routines \
--triggers \
--events \
"render-mysql-database" > /tmp/dump-file.sqlThen copy the file to your local machine:
# From your local machine
scp -s render-ssh-address:/tmp/dump-file.sql ./dump-file.sqlReplace render-ssh-address with the user@host part of the SSH command under Connect → SSH.
Import to Laravel Cloud
# From your local machine
mysql \
--host="cloud-db-host" \
--port="cloud-db-port" \
--user="cloud-db-username" \
--password="cloud-db-password" \
"cloud-db-database" < "dump-file.sql"On smaller Cloud MySQL instances, add --skip-extended-insert to the export to reduce memory use during import. For large databases, see the Laravel MySQL import notes.
Move your files (if you use a persistent disk)
Cloud's filesystem resets on every deploy, so uploads belong in object storage.
- Copy files off your Render disk with scp -s over SSH, or run wormhole send in the service's Shell and wormhole receive on your machine. On Docker services, install it first with apt update && apt install magic-wormhole. See Render's disk docs.
- Upload them to your Cloud bucket. See Migrating object storage to Laravel Cloud for tools and commands.
At this point, you are ready to deploy your application to Laravel Cloud by hitting the Deploy button. Follow the next steps to test whether everything is working correctly.
Test your Laravel Cloud deployment
Before switching DNS:
- Deploy your application: Click the Deploy button in Laravel Cloud.
- Verify deployment: Check the deployment logs for any errors.
- Test using Laravel Cloud URL: Every environment gets a .laravel.cloud URL.
- Run smoke tests: Verify critical functionality works.
- Check background jobs: Ensure queues are processing correctly.
- Check scheduled tasks: Confirm your scheduled commands run on time.
Switch DNS to Laravel Cloud
Once verified, point your domain to Laravel Cloud:
- In the Laravel Cloud dashboard, go to Domains and add your custom domain.
- Laravel Cloud will provide DNS records (A/CNAME).
- Update your DNS provider with the new records. Replace the CNAME to onrender.com, or the A record to Render's IP, and remove any AAAA records.
- SSL certificates are automatically provisioned and renewed.
Avoid downtime: Before you change your A or CNAME record, add the pre-verification TXT records that Cloud shows. This issues your SSL certificate before traffic moves. See custom domains.
Disable public database endpoint (optional)
After migration is complete and stable:
- Disable the public endpoint on your Laravel Cloud database for security.
- Your application will continue to access it via private network.
End your Render subscription
Once you've successfully deployed and tested your application, back up anything you still need, then delete your Render web service, background worker, cron job, databases, and persistent disks to stop all charges.
Common migration scenarios
Scenario 1: Standard Laravel app
Render setup: Docker web service + background worker + cron job + Postgres + KV store
Laravel Cloud setup: One application with Postgres + Laravel Valkey + managed queues + the Scheduler toggle
Estimated migration time: 30-60 minutes
Scenario 2: API-only application
Render setup: Docker web service + Postgres
Laravel Cloud setup: Postgres database + Valkey
Estimated migration time: 20-40 minutes
Scenario 3: Self-hosted MySQL
Render setup: Docker web service + MySQL private service with a persistent disk
Laravel Cloud setup: Managed MySQL database, with automated backups
Estimated migration time: 45-90 minutes
Scenario 4: Multi-environment setup
Render setup: Separate production and staging services
Laravel Cloud setup: Create separate environments in the same application
Estimated migration time: 45-90 minutes per environment
Code changes required
Minimal changes needed
Most Laravel applications need only small changes to move from Render to Laravel Cloud. Most of the work is deleting Docker and Render files.
Remove Render-specific files
If you followed Render's Laravel guide, you can delete:
- Dockerfile
- .dockerignore
- conf/nginx/nginx-site.conf
- scripts/00-laravel-deploy.sh
Also remove render.yaml if you used a Blueprint.
Move your build and deploy steps
Your Render deploy script ran Composer, caching, and migrations every time the container started. On Cloud, put that work in your environment's Deployments settings:
# Build commands
composer install --no-dev
npm ci --audit false
npm run build
php artisan optimize# Deploy commands
php artisan migrate --forceLaravel Cloud recommends against running optimize:clear, queue:restart, or storage:link.
HTTPS configuration
Render's guide either sets ASSET_URL or adds a forceScheme('https') call to your AppServiceProvider. Laravel Cloud serves your app over HTTPS with automatic certificates. You can leave the forceScheme call in place. Remove ASSET_URL if it points to your onrender.com address.
Queue configuration
Managed queues need Laravel 11.55.0, 12.63.0, 13.19.0, or newer and the AWS SDK package:
composer require aws/aws-sdk-phpCloud sets QUEUE_CONNECTION=cloud, so jobs you used to push to Redis or the database queue go to the managed queue. Let your Render background worker finish any pending jobs before you switch DNS.
Using Horizon? Managed queues don't support Horizon. Instead, keep your Redis connection and run php artisan horizon as a background process on your App cluster or a worker cluster. Don't add horizon:terminate to your deploy commands. Cloud handles it.
Scheduler configuration
On Render, a cron job or background worker runs your scheduler on one instance. On Cloud, your scheduler can run across multiple replicas when your app scales, meaning it could fire on every one of them.
Before you deploy, review your routes/console.php (or app/Console/Kernel.php) and add ->onOneServer() to any task that should only run once per schedule, such as reports, cleanup jobs, or anything that writes to your database or sends notifications.
use Illuminate\Support\Facades\Schedule;
Schedule::command('reports:generate')
->daily()
->onOneServer();This uses your cache to coordinate between instances, so make sure you have a KV store provisioned. For more details, see the Laravel scheduler documentation.
Storage configuration
If you stored uploads on a Render persistent disk, switch to Cloud object storage. Cloud's filesystem is ephemeral, and each replica has its own.
composer require league/flysystem-aws-s3-v3Use --with-all-dependencies if Composer reports a conflict. Cloud injects the bucket credentials and FILESYSTEM_DISK for you. If your bucket is public, copy AWS_URL from the bucket settings page into your environment variables, since Cloud doesn't inject it. Don't set visibility: 'public' in your disk config.
The same applies to sessions and cache: if they use the file driver, switch to database or redis.
Rollback plan
Before migrating production:
- Keep Render running until Laravel Cloud is fully validated.
- Parallel run: Test Laravel Cloud with real traffic using the Cloud URL.
- Database sync: If needed, you can sync databases before final cutover.
- DNS rollback: Keep old DNS records documented for quick rollback.
Post-migration validation
After successful migration:
1. Configure autoscaling
Set appropriate min/max replicas based on your traffic patterns.
2. Enable scale to zero
For staging and low traffic environments so you pay nothing when they are idle.
3. Check managed queues
Use the jobs dashboard to watch job volume, duration, and failed jobs.
4. Monitor performance
Use Laravel Cloud's built-in metrics to optimize compute resources.
5. Review costs
Compare your Laravel Cloud usage costs to previous Render bills.
Your Render to Laravel Cloud migration is now complete!
Migrating from Render to Laravel Cloud removes the Dockerfile, the extra worker and cron services, and the self-hosted database work, so you can focus on your application.
With zero-config environments, autoscaling, and a straightforward infrastructure model, most applications can be migrated in under an hour.
By following the steps in this guide, you can transition smoothly and start taking advantage of Laravel Cloud.
Why migrate from Render to Laravel Cloud?
“Laravel Cloud provides the programmable, seamless infrastructure that mirrors our own ambition, allowing us to slash our spend by 50% and shift our focus from managing servers to building the future of insurance.”
Craig Morris
Technical Program Manager at Superscript
Frequently asked questions
Most applications can be migrated in under an hour. Complex apps may take 2-4 hours.
No. Keep Render running while you set up Laravel Cloud, then switch DNS when ready.
No. Laravel Cloud runs PHP natively and builds your app from your build commands. You can delete the Dockerfile, nginx config, and deploy script.
Very little. You can delete Render's Docker files, add the AWS SDK package for managed queues, and add ->onOneServer() to scheduled tasks that should run once. See the Code changes required section.
You don't need them. Managed queues replace the background worker, and the Scheduler toggle replaces the cron job. Neither is a separate app you build or configure.
Export it with mysqldump from the MySQL service's Shell, copy the file to your machine, and import it into a managed MySQL database on Laravel Cloud. After that, you no longer host MySQL yourself.
Laravel's scheduler runs on Cloud without any infrastructure setup, but there's one behavior change to know about. On Render, a cron job or worker runs the scheduler once. On Cloud, if your app scales to multiple replicas, the scheduler runs on each one by default. Add ->onOneServer() to any task that should only fire once per schedule to prevent duplicate runs.
Copy them from each service's Environment page and any Environment Groups, then add your app-specific values in your environment's settings on Laravel Cloud. Cloud automatically injects credentials for any attached resources (database, cache, object storage), so leave out DATABASE_URL, DB_URL, REDIS_URL, and QUEUE_CONNECTION. Keep DB_CONNECTION. Redeploy after saving.
Yes. Laravel Cloud also runs Node.js, Bun, and Deno apps (Next.js, Nuxt, Express, Hono), Python (Django, FastAPI, Flask), Ruby on Rails, Go, and Rust. The database export, file transfer, and DNS steps in this guide work the same way. Build commands, environment variables, and background jobs differ by framework, so follow the deploy guide for your runtime. Managed queues and the Scheduler toggle are built for Laravel and Symfony. Other apps run background jobs and scheduled tasks on worker clusters.
Delete your Render services, databases, and persistent disks once migration is complete and validated to stop all charges.