Alternatives

Heroku alternative

Resilis vs Heroku: App and Postgres Hosting

Updated

Consider Resilis for an app with persistent data when you want a local agent deployment route, resource billing, or connected compute. Heroku remains a reasonable choice when its dyno model, add-ons, and managed data already fit your application.

When Resilis fits your Heroku app

Start with the processes your app actually runs. A web dyno, background worker, scheduler, and database are separate responsibilities, even if they appear together in one dashboard. List the start command, runtime version, port, filesystem use, and dependencies for each process. A successful build alone does not prove that every process has moved.

The Resilis workspace route uses local Git and a private Resilis-hosted repository through a connected agent. It does not require GitHub, but source is transferred off your machine. Review tracked and untracked files before upload. Alternatively, connect a GitHub repository in the dashboard. Agent access still requires authentication, organization selection, and authorized actions.

Compare a small app and PostgreSQL

Illustrative USD estimates before tax, for 30 days / 720 hours. Resilis app and PostgreSQL each average 0.25 billable vCPU and 0.5 GB RAM, with 10 GB database disk. Assumptions are not measurements or minimum sizes. Resilis uses binary GB; provider unit conventions can differ. Excludes app disk, egress, objects, build overage, HA, and outside infrastructure.

Heroku’s 10 GB combination is below the Resilis Hobby example, and its smaller entry database costs less again. Heroku database RAM is shared; Resilis assumes average usage, not an equivalent allocation. Basic is the always-on app tier used here; this comparison does not substitute an Eco sleeping app. Assess database connection and capacity limits before choosing the entry price.

Hobby: $10/month runtime credit, 200 build minutes. Pro: $50/month runtime credit, 500 build minutes. Pay the plan minimum plus eligible usage beyond credit; do not count usage twice. CPU: $0.004104/vCPU-hour; RAM: $0.00972/GB-hour; disk: $0.01/GB-day; database fee: $5/month Hobby or $10/month Pro. Build overage: $0.02/minute, separate from credit. Egress/object storage consume runtime credit. Raising database RAM to 1 GiB gives $19.98 Hobby or $24.98 Pro usage; Pro still bills $50.00.

Resilis billing source and current allowances — checked October 17, 2026.

Monthly estimates — prices checked October 17, 2026
Service / planCapacity and boundaryMonthly cost / official source
Resilis HobbyApp + PostgreSQL; 0.5 GB RAM each; 10 GB DB disk$16.48 usage and estimated bill; $10 credit floor
Resilis ProSame assumed resources; higher database service fee$21.48 usage; $50.00 estimated bill
Heroku Basic + Essential-1512 MB always-on app; shared DB RAM; 10 GB DB disk; 20 DB connections$7.00 + $9.00 = $16.00
Heroku Basic + Essential-0512 MB always-on app; shared DB RAM; only 1 GB DB disk; 20 DB connections$7.00 + $5.00 = $12.00; smaller entry option

Deployment and operational differences

Buildpacks and Procfile conventions need a deliberate mapping. Resilis uses Railpack for automatic builds and supports a Dockerfile route. Verify the detected runtime, build command, working directory, and start command with your repository. A Procfile or an add-on attachment is not a complete description of production behavior.

Audit add-ons individually. Mail, queues, search, monitoring, and object storage may remain external services with separate credentials and bills. Managed PostgreSQL or MySQL on Resilis does not replace every Heroku data product or extension. Preserve required external services until an alternative has passed an application-level test.

Workflow and ownership choices
RequirementHerokuResilis
Source and buildDyno/buildpack workflow; inventory Procfile processesGitHub dashboard route or agent/local Git; Railpack or Dockerfile
Data and extensionsManaged data and add-on choices; verify the selected offeringManaged PostgreSQL/MySQL; verify extensions and protection requirements
Existing infrastructureEvaluate the current Heroku deployment modelConnected Linux VPS/Kubernetes; own infrastructure costs remain

Plan a migration from Heroku

Rehearse with a disposable target and representative data. This checklist is not a completed app test. Assign a cutover owner and acceptance criteria.

  1. Inventory.

    Map web and worker dynos, config variable names, add-ons, scheduled tasks, and database attachments. Record which services stay external and who owns them.

  2. Build and configure.

    Translate the Procfile process into the intended start command. Test Railpack detection or a Dockerfile rather than assuming buildpack equivalence. Set secrets through sensitive configuration and bind DATABASE_URL. Never commit connection strings, log credentials, or paste them into agent conversations.

  3. Rehearse data transfer.

    Check PostgreSQL versions, extensions, roles, encoding, and clients. Use pg_dump --format=custom --no-owner and pg_restore --no-owner --no-acl --exit-on-error into a new, empty test database. Resolve grants/ownership separately. Use protected PostgreSQL service and password files. Apply chmod 600 to the password file. Never use command-line passwords. Encrypt dumps and restrict access. Remove dumps under your retention policy after verification.

  4. Verify behavior.

    Compare row counts and key records. Test authentication, writes, uploads, jobs, callbacks, and connectivity. Rebuild and confirm persistence; inspect sanitized logs.

  5. Freeze writes and cut over.

    Pause all writers on Heroku, including workers, jobs, and integrations. Repeat the final dump/restore and verify data before enabling destination writes. Prepare the managed-app domain and TLS. Lower the DNS TTL ahead of time where appropriate. Change DNS after serving checks. Keep one authoritative writer despite cached DNS.

  6. Bound rollback.

    Retain the source and a verified backup until acceptance. DNS can route back, but after destination writes begin, reconcile those writes before switching databases. App rollback does not restore data or reverse schema migrations. Agree on the data-loss boundary and recovery procedure before cutover; retire old resources only after approval.

Choose the compute and recovery boundary

Resilis offers managed compute or connected VPS/Kubernetes, with managed PostgreSQL/MySQL. External S3, R2, and B2 connections register existing buckets. They do not provision or migrate buckets. MCP setup needs no paid plan; authentication and operation entitlements apply. Connected infrastructure retains its bill and duties. Custom domains are unavailable on connected compute and S3-backed static sites.

Verify entitlements, backups, restore points, and a restore rehearsal. Lower estimates do not establish equivalent availability, support, recovery time, or capacity.

When staying on Heroku makes sense

Stay when the small entry combination meets your needs, your add-ons remove operational work, or moving would introduce more risk than the expected benefit. Include engineering time, testing, temporary overlap, and the cost of retained services in the decision. A different billing model is useful only if it fits the actual workload and the team can operate the result.

Frequently asked questions

Is Resilis always less expensive than Heroku?

No. The $12.00 Basic and Essential-0 entry option has less database disk, and the $16.00 Essential-1 combination is also below this $16.48 Resilis example. Capacity, add-ons, and operational requirements must be compared alongside the bill.

Can I keep my existing database during evaluation?

You can plan a staged evaluation around your existing data service if connectivity and access controls permit it. Test latency, network charges, and credentials first. Do not expose a private database just to make an initial experiment easier.

Will a Heroku app run without changes?

Do not assume that. Review buildpack behavior, Procfile processes, environment variables, filesystem assumptions, and add-ons. Use a test target and verify real app behavior before scheduling the move.

Evaluate your own workload