Leaving DigitalOcean App Platform: a migration checklist for a small team
DigitalOcean App Platform is a good first home: push to GitHub, get a URL. As the product grows, each new piece (a worker, a bigger instance, a database) is another component with its own price, and the containers keep no files between deploys.
This post is the checklist for moving a small App Platform app to a server you own: where each piece goes, and the steps to switch in one short maintenance window. You can even stay on DigitalOcean and move to a Droplet.
Disclosure: we build DollarDeploy, a control plane that deploys and operates apps on servers you own. The checklist works with any setup. Where DollarDeploy covers a step, we say so, and where it does not, we say that too.
Why teams leave
Why it matters: App Platform is simple while the app is one service. With a worker, a database and scheduled work, the CTO starts assembling and paying for parts.
- Every component is billed on its own. A web service, a worker and a database are three line items; shared instances run from $5 (512 MiB) to $50 (4 GiB) a month.
- No files survive a deploy. The container filesystem is not persistent, so uploads and generated files need object storage (Spaces) from day one.
- Shared instances do not autoscale. For more headroom you move to a bigger size or to dedicated instances.
- The dev database is for development. It is a 512 MiB PostgreSQL at $7/mo; production data means a managed database cluster, another bill.
The big picture: a small app, its worker and its database fit on one server. The question is who looks after that server, not whether you need four separate components.
App Platform piece by piece
Use this as the map. Left: what you use on App Platform. Right: where it goes on your own server, and what DollarDeploy does for it.
- Deploy on push: connect the GitHub repo once in DollarDeploy, and every push to the branch you pick builds and deploys.
- Buildpacks or a Dockerfile: usually no Dockerfile needed. DollarDeploy detects common stacks (Node.js, Next.js, Python, Go and more), fills in the build and start commands, and runs the app as a service without Docker. If the app only runs from its Dockerfile, add a short
docker-compose.ymlthat builds it: Docker Compose apps are supported too. servicesandworkers: one app per component from the same repo, each with its own start command, on the same server.jobsof kindPRE_DEPLOY(migrations before the new version starts): the Custom pre start shell command in the app settings.- App-level and component
envs: app env vars. They are stored encrypted, and hidden from teammates without write access to that app. - Dev database or a managed PostgreSQL / Redis cluster: PostgreSQL and Redis installed on your server with one click, on localhost, next to the app.
- Spaces for files: you can keep Spaces. Or use a folder inside the app's directory on the server, which is included in the app's backups.
- Scheduled work: the app's Cron tab, with any cron expression. Each run is a task with logs, retries and a notification when a job starts failing (paid plans).
- Domains and certificates: HTTPS from Let's Encrypt for every app domain, renewed for you.
- Runtime logs and insights: 30 days of app logs and monitoring on paid plans (3 days on Free).
- Rollback to a previous deployment: the Builds table, where Deploy on any earlier build ships it again without rebuilding.
- Team members: roles per team, project, app or server (View, Deploy, Write, Maintain, Admin), so a contractor can deploy one app without touching the server.
The server work is covered too: DollarDeploy prepares the server with a firewall and automatic security updates, and Inspect checks 13 areas of it (disk, memory, services, certificates, SSH logins and more) without changing anything.
The migration, step by step
Plan for one maintenance window of 15-60 minutes, depending on the size of your database. Everything before it can happen during the week.
- Lower your DNS TTL to 5 minutes, two days ahead. The final switch then takes minutes instead of hours.
- Export the app spec:
doctl apps spec get <app id> > app.yaml. It lists every service, worker, job, env var, database and domain, so nothing gets forgotten. - Collect your secrets. In the spec,
SECRETenv vars show only asEV[...]ciphertext. Take the values from your password manager or the App Platform console, or print them from the app's Console tab withenv. Keep the result out of git. - Get a server in the region your app runs in. One server with 2 GB of memory usually runs a small app, its worker and its database. Link your DigitalOcean account in DollarDeploy's Integrations and it creates the Droplet for you (Hetzner, Vultr and AWS in selected regions work too), or connect any server over SSH.
- Create one app per service and worker from your GitHub repo and paste the env vars. Point
DATABASE_URLat the new database: DollarDeploy exposes the local PostgreSQL asPOSTGRES_URL, and Redis asREDIS_URL. - Deploy it on a temporary domain and run through your app with a copy of the data. Fix build differences now, not during the window.
- Add the cron jobs and send deploy, cron and backup notifications to the channel your team reads (Slack, Telegram, Discord, email or a webhook).
- Start the window: stop writes (show a maintenance page or stop the components), then dump the database with
pg_dump -Fc, using the connection string from the database's settings in the DigitalOcean control panel. - Restore it on the new server with
pg_restore, switch DNS, and check the app from outside your network. Keep the App Platform app for a few days in case you need to go back, then delete it so it stops billing. - Take a backup and restore it once on the new server. A backup you have not restored is a guess.
Yes, but
You now own a server. DollarDeploy keeps it updated and checked, but capacity is your call: there is no autoscaling across machines. For spiky traffic, size the server for the peak.
One server is one failure domain. App Platform can run several containers of a service. On one server, a hardware problem takes everything down until it is back, which is why the restore test in step 10 matters.
Cron runs are capped at 60 seconds. Long jobs should run in your worker instead, with the cron only starting them.
Our honest limit: DollarDeploy does not page anyone when your app is down, so add an external uptime monitor. We are also a small team without a public SLA or status page yet. If you need contractual uptime guarantees, factor that in.
By the numbers
Cost is not the reason to move, but you should know it. On App Platform, a 1 GiB web service ($12), a 512 MiB worker ($5) and the dev database ($7) are $24/mo, before a production database. On a server you own in the US or London, the same app, worker and PostgreSQL are $15/mo all-in: DollarDeploy Hobby $5 plus a Vultr 1 vCPU / 2 GB server at $10.
The bottom line
Leaving App Platform makes sense when your app has grown into several components and you want them in one place you control. Export the spec, rehearse on a temporary domain, and the switch itself is one short window.
Go deeper: Leaving Fly.io: a migration checklist for a small team, Leaving Heroku: a migration checklist for a small team and Backups for a small startup: what to keep and how to test a restore.
Your services, worker and database on one server, with the ops carried for you. DollarDeploy deploys every component from GitHub to a server you own, including a Droplet, and runs the work around it: builds without a Dockerfile, one-click rollback, HTTPS, logs and monitoring, PostgreSQL and Redis, cron jobs with failure alerts, backups and server updates. Nothing for you to maintain. Start free on DollarDeploy, no card needed.