From VPS to PaaS: Why Developers Are Making the Switch

From VPS to PaaS: Why Developers Are Making the Switch

There's a certain pride in managing your own VPS. You know every cron job, every nginx config line, every systemd unit file. But that pride comes with a real cost: every hour spent on server maintenance is an hour not spent on your product. This guide examines the honest trade-offs between VPS and PaaS, and walks through the practical steps to migrate your VPS workloads to a modern cloud platform.

The Real Cost of a VPS

A $10/month VPS sounds cheap until you add up the hidden costs:

• Security patching: apt upgrade is easy; auditing what changed and whether it breaks your app is not.
• SSL renewal: Even with Certbot, certificate failures happen — usually at midnight.
• Backup management: Setting up and verifying offsite backups is a weekend project.
• Scaling: Vertical scaling requires downtime. Horizontal scaling requires load balancers, shared sessions, and sticky routing configuration.
• Monitoring: Grafana, Prometheus, alerting — each is a project unto itself.

For solo developers and small teams, this overhead often exceeds the cost of a comparable PaaS.

What You Actually Get From a PaaS

A cloud PaaS like PandaStack handles infrastructure so you focus on code:

• Auto-deploys on every GitHub push — no SSH, no rsync, no pm2 restart
• Managed databases (PostgreSQL, MySQL, Redis, MongoDB) with backups and connection pooling
• SSL automatically provisioned and renewed
• Cronjobs as first-class resources — no crontab editing over SSH
• Edge functions (Node.js and Python via OpenWhisk) for lightweight serverless workloads
• Managed WordPress and Drupal — no wp-cli over SSH, no plugin update sprawl

Free tier available, with paid plans starting at $12/mo.

Step 1: Audit Your VPS

Before migrating, understand exactly what your VPS is running:

# What services are running?
systemctl list-units --type=service --state=running

# What's listening on which ports?
ss -tlnp

# What cron jobs exist?
crontab -l
cat /etc/crontab
ls /etc/cron.d/

# What nginx vhosts do you have?
ls /etc/nginx/sites-enabled/
nginx -T | grep server_name

# What databases are running?
systemctl status postgresql mysql redis-server 2>/dev/null

Step 2: Export Your Database

# PostgreSQL
sudo -u postgres pg_dump   --format=custom   --no-acl   --no-owner   --compress=9   mydb > vps-postgres-backup.dump

# MySQL
mysqldump   --single-transaction   --routines   --triggers   --all-databases > vps-mysql-backup.sql

# Redis (if using for persistent data)
redis-cli BGSAVE
cp /var/lib/redis/dump.rdb ./vps-redis-backup.rdb

Download all backups to your local machine immediately.

Step 3: Containerize Your Application

The biggest shift from VPS to PaaS is moving from "app running as a process on a host OS" to "app running in a container." This is non-negotiable — and it's actually good for you.

For a typical Node.js app managed with PM2 on your VPS:

# What PM2 is running
pm2 list
pm2 show your-app-name

Create a Dockerfile that replaces PM2:

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY src/ ./src/
RUN addgroup -S app && adduser -S app -G app
USER app
EXPOSE 3000
HEALTHCHECK --interval=30s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "src/server.js"]

For a Python app managed with Gunicorn + Supervisor:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt gunicorn
COPY . .
RUN useradd -m appuser && chown -R appuser /app
USER appuser
EXPOSE 8000
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "2", "--timeout", "120"]

Step 4: Migrate VPS Cron Jobs to PandaStack Cronjobs

Every line in your crontab -l output becomes a PandaStack cronjob:

npm install -g @pandastack/cli
panda login

# VPS cron: 0 2 * * * /usr/bin/python3 /opt/app/scripts/backup.py
panda cronjob create   --name nightly-backup   --image ghcr.io/your-org/your-app:latest   --schedule "0 2 * * *"   --command "python scripts/backup.py"

# VPS cron: */15 * * * * /usr/bin/node /opt/app/scripts/health-check.js
panda cronjob create   --name health-check   --image ghcr.io/your-org/your-app:latest   --schedule "*/15 * * * *"   --command "node scripts/health-check.js"

Step 5: Restore Databases on PandaStack

export PS_DB="postgresql://user:pass@pandastack-host:5432/mydb"

pg_restore   --no-acl   --no-owner   --verbose   --jobs=4   -d "$PS_DB"   vps-postgres-backup.dump

# Verify
psql "$PS_DB" -c "SELECT COUNT(*) FROM users;"

Step 6: Deploy and Cut Over

# Push Dockerfile to GitHub
git add Dockerfile .dockerignore
git commit -m "Add Docker configuration for PandaStack deployment"
git push origin main

# PandaStack auto-deploys on push
# Monitor the build at dashboard.pandastack.io

# Test the new deployment
curl -I https://my-app.pandastack.io
curl https://my-app.pandastack.io/api/health

# When satisfied, update DNS
# Lower TTL 24 hours before: change to 60 seconds
# After cutover: point CNAME to my-app.pandastack.io

The Math

For a typical VPS setup costing $20/month (with a developer spending 3 hours/month on maintenance at $150/hr), the real monthly cost is $470. PandaStack's paid plans start at $12/month with zero maintenance overhead. The switch pays for itself on day one.

The VPS gives you control. The PaaS gives you time. Most developers, once they've made the switch, don't go back. Get started at [dashboard.pandastack.io](https://dashboard.pandastack.io) and read the docs at [docs.pandastack.io](https://docs.pandastack.io).