Move from Supabase to
DigitalOcean

I just created an Ubuntu 22.04 server on DigitalOcean.
IP: [YOUR_IP]
Root password: [YOUR_PASSWORD]

SSH into it and set it up:
1. Update all packages (apt update && apt upgrade -y)
2. Configure UFW firewall — allow only ports 22, 80, and 443
3. Install Node.js 20 (use NodeSource)
4. Install PostgreSQL 15
5. Install Nginx
6. Install PM2 globally (npm install -g pm2)

Do each step and tell me when it's done.

Create a folder called "migration" on the Desktop.

Then run this command (use my Supabase DATABASE_URL):

pg_dump "[DATABASE_URL]" --schema=public --no-owner --no-privileges -f ~/Desktop/migration/backup.sql

When it finishes, tell me how many lines the file has and show me all the CREATE TABLE lines in it.

Server IP: [YOUR_IP], root password: [YOUR_PASSWORD]
Backup file: ~/Desktop/migration/backup.sql

Do this:
1. Send the backup file to the server using scp
2. On the server: create a PostgreSQL database called "myapp"
3. Create a user called "appuser" with a strong password (tell me what password you picked)
4. Import the backup.sql into that database
5. List all the tables to confirm everything imported correctly

My tables are: [list your table names here, example: users, products, orders]

I'm using Supabase Auth in this Next.js project. Replace it with a custom JWT system.

First, list every file that uses supabase.auth so I can see what we're changing.

Then make these changes:
1. Create a SQL file that adds a users table: id (UUID), email, password_hash, email_confirmed (boolean), created_at
2. Create lib/user-auth.ts with: createUser(), signIn(), verifyToken() — use bcryptjs for passwords, jsonwebtoken for tokens
3. Create API routes: POST /api/auth/signup, POST /api/auth/login, POST /api/auth/logout, GET /api/auth/me
4. Replace supabase.auth.signUp() → POST request to /api/auth/signup
5. Replace supabase.auth.signInWithPassword() → POST request to /api/auth/login
6. Replace supabase.auth.getSession() → read "app_token" from localStorage, verify with /api/auth/me
7. Replace supabase.auth.signOut() → POST to /api/auth/logout, clear localStorage

Tokens go in localStorage as "app_token", expire in 30 days.

Show me each file change one at a time.

Now replace all the database queries.

1. Install postgres.js: npm install postgres
2. Create lib/db.ts — connect to PostgreSQL using the DATABASE_URL environment variable
3. Find every file that uses supabase.from() and replace each one:
   - supabase.from('table').select() → sql`SELECT * FROM table`
   - supabase.from('table').insert(data) → sql`INSERT INTO table (...) VALUES (...)`
   - supabase.from('table').update(data).eq() → sql`UPDATE table SET ... WHERE ...`
   - supabase.from('table').delete().eq() → sql`DELETE FROM table WHERE ...`
4. Add DATABASE_URL to .env.local pointing to the new server:
   postgresql://appuser:[password from step 05]@[YOUR_IP]/myapp

Show me every file you change.

Set up email sending with Resend.

1. Install: npm install resend
2. Create lib/email.ts with a sendEmail(to, subject, html) function using the Resend API
3. Add buildVerificationEmail(verifyUrl) — dark background, red button, clean HTML email
4. Add buildPasswordResetEmail(resetUrl) — same style
5. In /api/auth/signup — after creating the user, send a verification email
6. Add RESEND_API_KEY=[YOUR_RESEND_KEY] and EMAIL_FROM=noreply@yourdomain.com to .env.local

RESEND_API_KEY: [YOUR_RESEND_KEY]

Deploy my Next.js app to my DigitalOcean server.

Server IP: [YOUR_IP], root password: [YOUR_PASSWORD]
GitHub repo: [github.com/yourname/yourrepo]

Steps:
1. SSH into the server
2. Clone the repo to /var/www/myapp
3. Create /var/www/myapp/.env.local with these values:
   DATABASE_URL=postgresql://appuser:[password]@localhost:5432/myapp
   JWT_SECRET=[generate a random 32-character string]
   RESEND_API_KEY=[my key]
   EMAIL_FROM=noreply@[my domain]
   NEXT_PUBLIC_APP_URL=http://[YOUR_IP]
4. Run: npm ci && npm run build
5. Start with PM2: pm2 start npm --name myapp -- start
6. Run pm2 save and pm2 startup
7. Set up Nginx to forward http://[YOUR_IP] to localhost:3000
8. Open http://[YOUR_IP] in the browser — tell me if the app loads

Set up GitHub Actions so every push to main auto-deploys to my server.

Server IP: [YOUR_IP], user: root
GitHub repo: [github.com/yourname/yourrepo]

Do this:
1. On the server: generate a deploy SSH key (ssh-keygen -t ed25519 -f ~/.ssh/github_deploy -N "")
2. Add the public key to authorized_keys
3. Show me the private key — I'll add it to GitHub Secrets
4. Create .github/workflows/deploy.yml:
   - Triggers on push to main
   - Builds the app on the GitHub runner (not on the server)
   - SSHes in and runs: git pull, npm ci --omit=dev, npm run build, pm2 restart myapp
5. Tell me exactly which GitHub Secrets I need to add and what values to use