Sevalla has the best feature parity with Heroku on the market. No other alternative covers as many Heroku features out of the box.
Heroku has transitioned to maintenance-focused support as of February 2026. With Sevalla, you get the same workflow youāre used to (buildpacks, Procfiles, pipelines, preview apps, 12-factor architecture) without having to rethink how you deploy. Bring your existing Git repos, buildpacks, or Docker images and get running without changes.
This guide covers how Heroku concepts map to Sevalla, so you can plan your migration with confidence.
Why migrate to Sevalla
Beyond Herokuās shift to maintenance mode, Sevalla provides several advantages:
- Lower costs - Competitive pricing with no surprise add-on fees. Databases, object storage, CDN, and DDoS protection are integrated into the platform rather than sold as third-party add-ons.
- Built-in CDN and edge caching - Powered by Cloudflareās global network spanning 260+ cities in 100+ countries. Enabled with a single click, no add-on required.
- DDoS protection included - Enterprise-level Cloudflare DDoS protection on every application at no extra cost.
- Private networking - Internal connections between your applications and databases stay within the network, with no exposure to the public internet.
- Flexible build options - Choose between Nixpacks (20+ languages), Heroku Buildpacks, or your own Dockerfile.
- Preview environments - Automatically generated for pull requests through pipelines, making it easy to test changes before promoting to production.
- Persistent storage - Attach disks directly to your application pods, something Heroku doesnāt natively support.
- Modern analytics - Built-in compute and web analytics with request metrics, country-level breakdowns, response times, and zoomable charts.
Feature mapping
The tables below show how Heroku features and terminology map to their Sevalla equivalents.
Compute
| Heroku | Sevalla |
|---|
| App | Application |
| Dyno | Process |
| Dyno type (Eco, Basic, Standard, Performance) | Process size (Hobby, S1, S2, etc.) |
| Web dyno | Web process |
| Worker dyno | Background worker |
| Heroku Scheduler / clock process | Cron job |
One-off dyno (heroku run) | Job process |
| Config vars | Environment variables |
| Dyno scaling (manual) | Manual scaling (vertical and horizontal) |
| Autoscaling (Performance dynos) | Automatic horizontal scaling (CPU-based) |
Deployment
| Heroku | Sevalla |
|---|
| Git push deploy | Git deploy (GitHub, GitLab, Bitbucket) |
| Container Registry deploy | Docker image deploy (Docker Hub, GHCR, GitLab Registry) |
| Buildpacks | Buildpacks or Nixpacks (default) |
| Procfile | Procfile (also supported) |
Release phase (release process) | Job process (before/after deployment) |
| Preboot (zero-downtime deploys) | Health checks (readiness and liveness probes) |
| Review apps | Preview apps (via pipelines) |
| Pipelines (dev ā staging ā prod) | Pipelines with promote support |
| Deploy hooks (HTTP notification) | Deploy hooks (trigger deploys via POST) |
| Automatic deploys from branch | Automatic deployment on push |
Networking
| Heroku | Sevalla |
|---|
| Custom domains | Custom domains with free auto-SSL via Cloudflare |
| SSL certificates (ACM) | Automatic free SSL (included with every domain) |
| Private Spaces networking | Private networking (internal connections) |
| - | CDN (Cloudflare, 260+ cities, free) |
| - | Edge caching |
| - | IP restrictions (allowlist/denylist) |
| - | TCP proxy (expose non-HTTP services) |
Datastores
| Heroku | Sevalla |
|---|
| Heroku Postgres | PostgreSQL |
| JawsDB MySQL (add-on) | MySQL |
| - | MariaDB |
| Heroku Key-Value Store (Redis) | Redis |
| - | Valkey |
| - | Database Studio (built-in management UI) |
| PG Backups | Automatic daily backups (7-day retention) + manual backups |
Storage and assets
| Heroku | Sevalla |
|---|
| Ephemeral filesystem | Ephemeral filesystem (default) |
| - | Persistent storage (10 GB-1 TB attachable disks) |
| S3 add-on (third-party) | Object storage (S3-compatible, powered by Cloudflare R2) |
Observability
| Heroku | Sevalla |
|---|
| Application logs | Runtime logs (up to 30 days, filterable) |
| Log drains | Runtime logs with structured data, JSON/CSV export |
| Heroku Metrics | Analytics (CPU, memory, RPM, response time, status codes, country breakdown) |
| - | Webhooks (deployment events, app/database/static site lifecycle) |
| Heroku | Sevalla |
|---|
| Heroku Teams | Company settings with role-based user management |
| Heroku API | Sevalla API |
| SSO (Enterprise) | SSO (Google, Microsoft, Okta, OneLogin, Ping) |
| - | Static site hosting (free) |
| - | Templates (one-click deploy) |
| - | Hibernation (auto-sleep idle apps, wake on traffic) |
Enterprise and security
| Heroku | Sevalla |
|---|
| SOC 2 Type II | SOC 2 Type II |
| ISO 27001 | ISO 27001 |
| GDPR | GDPR |
| DDoS protection (Private Spaces) | Built-in Cloudflare DDoS protection (all plans) |
| SSO (Enterprise only) | SSO (all plans) |
| Team roles | Role-based access control |
| 2FA | 2FA (required for all accounts) |
| 99.9% uptime SLA | 99.9% uptime SLA |
Phase 1: Prepare to migrate
Before moving anything, take inventory of your Heroku setup so nothing gets missed.
Create a Sevalla account
Sign up at sevalla.com if you havenāt already. You can explore the dashboard and create resources before committing to a migration.
Catalog your Heroku resources
For each Heroku app, document the following:
-
Procfile processes - List every process type and its command. Each one maps to a Sevalla process:
web: npm run start
worker: npm run worker
release: npm run migrate
-
Config vars - Export all environment variables. You can import these into Sevalla via the dashboard or by uploading a
.env file.
-
Add-ons - Identify your Heroku Postgres, Redis, and any third-party add-ons. Many third-party services (like SendGrid, Mailgun, or Sentry) continue working after migration since they connect via environment variables.
-
Custom domains - Note all custom domains and their DNS configuration.
Phase 2: Recreate your app on Sevalla
Step 1: Create datastores first
Create your databases before deploying your application so the app can connect immediately on first deploy.
You are not moving data yet. This step creates empty databases for your application to connect to. Data migration happens in Phase 3.
To create a database:
- In the Sevalla dashboard, go to Databases > Create database
- Select the database type and version (PostgreSQL, MySQL, MariaDB, Redis, or Valkey)
- Configure the database name, user, and password
- Select a data center location - this must match the location you choose for your application to enable internal connections
- Choose a resource size and click Create database
Repeat for each datastore you need to migrate (e.g. one for Postgres, one for Redis).
Step 2: Create your application
- In the dashboard, go to Applications > Create > Application
- Connect your Git provider (GitHub, GitLab, or Bitbucket) and select your repository, or deploy from a Docker image
- Choose the same data center location as your databases
- Select a process size
Donāt deploy yet. Configure your environment variables and processes first.
- Go to your applicationās Environment variables tab
- Add your Heroku config vars - you can paste key=value pairs in bulk or import a
.env file
- Set each variableās availability to Runtime, Build, or both
Sevalla does not automatically set NODE_ENV to production. Add it manually if your application depends on it.
Step 4: Set up internal connections
Connect your application to the databases you created in Step 1:
- Go to your applicationās Networking tab
- Under Connected services, click Add internal connection
- Select the database and check Add environment variables to the application to auto-populate connection details (e.g.
DATABASE_HOST, DATABASE_PORT, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)
- Click Add connection
Internal connections stay within the Sevalla network and are faster and more secure than external connections.
Step 5: Set up processes
If your Heroku app uses multiple Procfile processes, add the equivalent processes in Sevalla:
- Go to your applicationās Processes tab
- Update the web process start command if needed
- Click Create new process to add background workers, cron jobs, or jobs as needed
| Heroku Procfile entry | Sevalla process type |
|---|
web: npm run start | Web process (auto-created) |
worker: npm run worker | Background worker |
release: npm run migrate | Job (start policy: āBefore deploymentā) |
| Clock process / Heroku Scheduler | Cron job (with cron expression) |
Sevalla defaults to Nixpacks for builds. If you prefer to keep using Heroku Buildpacks:
- Go to Settings > Build strategy > Update build strategy
- Select Buildpacks and choose the appropriate Heroku builder
You can also switch to a Dockerfile if your project uses one.
Phase 3: Migrate data and go live
This phase requires brief downtime for your application. Schedule it during off-peak hours.
Step 1: Enable maintenance mode on Heroku
Prevent new writes to your Heroku database during migration:
heroku maintenance:on --app YOUR_HEROKU_APP_NAME
Step 2: Export your Heroku database
PostgreSQL:
heroku pg:backups:capture --app YOUR_HEROKU_APP_NAME
heroku pg:backups:download --app YOUR_HEROKU_APP_NAME
This creates a latest.dump file locally.
Redis:
Export your Redis data using the method appropriate for your dataset size. For smaller datasets, you can use redis-cli with the --rdb flag or a tool like redis-dump.
Step 3: Import data into Sevalla
Get your Sevalla databaseās external connection details from the databaseās Networking tab (enable external connections temporarily if needed).
PostgreSQL:
pg_restore --verbose --no-acl --no-owner -d "SEVALLA_EXTERNAL_CONNECTION_STRING" latest.dump
MySQL:
mysql -h HOSTNAME -u USERNAME -P PORT -p DATABASE_NAME < export.sql
For detailed import instructions, see the database-specific guides:
Alternative: Server-to-server migration without downloading
If downloading the database to a local machine is not an option (e.g. for security or compliance reasons, or the dataset is too large), you can spin up a lightweight Sevalla application that migrates data directly between the two databases. Data flows server-to-server and never touches a local machine.
- Create a new Sevalla application with a Dockerfile that includes the database client tools you need (e.g.
postgres:17 or mysql:9 images already have them)
- Add environment variables for both the Heroku source and Sevalla target connection strings
- Set the start command to pipe the export directly into the import:
PostgreSQL:
pg_dump --no-acl --no-owner -d "$SOURCE_DATABASE_URL" | pg_restore --no-acl --no-owner -d "$TARGET_DATABASE_URL"
MySQL:
mysqldump --no-tablespaces -h $SOURCE_HOST -u $SOURCE_USER -P $SOURCE_PORT -p$SOURCE_PASSWORD $SOURCE_DB | mysql -h $TARGET_HOST -u $TARGET_USER -P $TARGET_PORT -p$TARGET_PASSWORD $TARGET_DB
- Deploy the application and monitor the logs to track progress
- Once the migration completes, delete the migration application
This approach keeps your data in transit between servers only, which is important for large databases and environments with strict data handling policies. Make sure both databases are accessible from the Sevalla applicationās data center.
Step 4: Deploy your application
Go to your applicationās Deployments page and click Deploy now. Monitor the deployment log to verify everything builds and starts correctly.
Step 5: Update DNS records
Once your application is running on Sevalla:
- Go to your applicationās Domains tab and add your custom domain
- Add the TXT record for domain verification at your DNS provider
- Add the CNAME record for SSL certificate provisioning
- Update your A record to point to the IP address provided by Sevalla
- Allow time for DNS propagation
For step-by-step instructions, see Custom domains.
Step 6: Verify and disable Heroku
After confirming your application works correctly on Sevalla:
- Test all critical functionality
- Verify database data integrity
- Check that background workers and cron jobs are running as expected
- Disable external connections on your Sevalla database if you enabled them for import
- Scale down or delete your Heroku resources
Whatās next
Now that your application is running on Sevalla, explore these features:
- Pipelines - Set up dev/staging/production environments with preview apps
- CDN and edge caching - Enable the built-in Cloudflare CDN for faster delivery
- Analytics - Monitor performance with built-in compute and web analytics
- Auto-scaling - Configure automatic horizontal scaling based on CPU usage
- Webhooks - Get notified about deployment events and resource lifecycle changes