⚪Sliplane Deploy

A guide on how to deploy your LightningRails app to sliplane

Sliplane is now my favorite hosting provider, it is very easy to deploy and you can have several apps under the same server, great if your apps haven't picked up momentum without having to spend hundreds of $ on Heroku servers.

---

After doing the setup, Sliplane’s mental model is:

1. Create a Server (your machine)

2. Create a Project (a group for one app and its services)

3. Add services inside the project (Postgres, Redis, your Rails app from GitHub)

4. Add env vars, deploy, then optionally add a custom domain

5. Use the built-in console (SSH) when you need to run Rails commands

Bonus: you can host several apps on the same server, which is awesome for keeping costs down. Each app is just another Project on that same Server.

---

0. Prerequisites

• Your Lightning Rails app is pushed to GitHub (main branch recommended)

• You have a Sliplane account

• You are ready to set production env vars (Cloudinary, OpenAI, Stripe, etc if your app uses them) from your .env file

---

1. Prepare your app (Choose based on your case)

💡 For updating existing apps

# One-time setup (if not already done)
gh auth login

# Fetch the Sliplane setup files and add them to your project

# 1. Fetch the rake task
gh api repos/LightningRails/lightning-rails/contents/lib/tasks/sliplane_setup.rake \
  --jq '.content' | base64 -d > lib/tasks/sliplane_setup.rake

# 2. Fetch the bash script
gh api repos/LightningRails/lightning-rails/contents/bin/setup-sliplane \
  --jq '.content' | base64 -d > bin/setup-sliplane

# 3. Make the bash script executable
chmod +x bin/setup-sliplane

# 4. Commit the changes
git add lib/tasks/sliplane_setup.rake bin/setup-sliplane
git commit -m "Added Sliplane deployment setup"

# 5. You're ready to deploy!
rails sliplane:setup

🆕 For a new app

From your project root:

bin/rails sliplane:setup

This command will:

• Create a production-ready Dockerfile

• Create .dockerignore

• Create bin/docker-entrypoint

• Create .env.example

• Generate a SECRET_KEY_BASE

• Print all required environment variables

• Show the Sliplane deployment checklist

Then push your code:

git add .
git commit -m "Prepare for Sliplane"
git push origin main

That’s it on the code side.

---

2. Create a Server in Sliplane

1. Go to Sliplane

2. Click Create Server

3. Choose a region

4. Choose an instance size (start small, scale later)

5. Wait until the server is ready

You can deploy multiple apps on the same server by creating multiple Projects.

---

3. Create a Project (your app)

1. Click Create Project

2. Name it something like:

myapp-production

Inside this project, you’ll add services.

---

4. Add a PostgreSQL service (Required)

Inside your project:

1. Click Add Service

2. Choose PostgreSQL

3. Set it to Private (not public) ⚠️

4. Add a Volume (Leave default)

5. Set (Leave default):

• POSTGRES_USER

• POSTGRES_PASSWORD (mark as Secret)

• POSTGRES_DB

1. Add

Deploy it.

Once live, note the variables above and the internal hostname You’ll need it for DATABASE_URL.

---

5. Add Redis (Optional)

If your app uses:

• Caching

• ActionCable

• Very complex Background jobs

• Sidekiq

Then:

1. Add Service → Redis

2. Set to Private

3. Add a volume (optional)

4. Deploy

If not, you can skip this and use a SolidQueue setup (Guide coming soon)

---

6. Add Your Rails App (Repository Service)

Inside your project:

1. Click Add Service

2. Choose Repository

3. Connect your GitHub repo

4. Select branch (usually main or master)

5. Sliplane will detect your Dockerfile

6. ⚠️ Make sure the privacy toggle is set to TRUE! Or you won't be able to add a domain.

Set (Default):

• Public: Enabled

• Protocol: HTTP

• Healthcheck path: /

Deploy.

Sliplane will now build your Docker image and compile assets.

---

7. Add Environment Variables

Go to your Rails service → Settings → Environment Variables.

Add all the variables found in your .env file.

Required

RAILS_ENV=production
SECRET_KEY_BASE="Find this key in the terminal when you ran the script"
RAILS_SERVE_STATIC_FILES=true
RAILS_LOG_TO_STDOUT=true

Database URL

Go to your PostgreSQL service and find the variables in "settings". Here is where we link our brand new PostgreSQL service with our brand new repository service.

Build it using your Postgres service:

postgresql://USER:PASSWORD@INTERNAL_HOST_URL:5432/DB_NAME

Example shape:

postgresql://app_user:[email protected]:5432/production_db

Add it as:

DATABASE_URL=...

---

Third-Party Keys (if your app uses them)

If your Lightning Rails app uses external services, add them here:

Examples:

• CLOUDINARY_URL

• OPENAI_API_KEY

• STRIPE_PUBLIC_KEY

• STRIPE_SECRET_KEY

• POSTMARK_API_TOKEN

If it exists in your .env locally or in your previous hosting provider's config, it likely belongs here in production.

---

8. First Deploy Checklist

Once deployed:

• Visit your Sliplane URL (*.sliplane.app)

• Confirm styles are loading

• Test login / registration

• Check logs if anything fails

If styles are missing, make sure:

RAILS_SERVE_STATIC_FILES=true

is set.

---

9. Add a Custom Domain (Private Domain)

To use your own domain:

1. Open your Rails service

2. Go to Domains

3. Add your domain (example: app.yourdomain.com)

4. Sliplane will show required DNS records

Usually:

• For subdomain → create a CNAME

• For root domain → follow the exact record Sliplane provides

Once DNS propagates, SSL is handled automatically.

You can then update:

RAILS_HOST=app.yourdomain.com

in environment variables if needed.

---

10. Open Console (SSH)

Useful for:

• Running migrations

• Seeding data

• Rails console

Step 1 – Add your SSH key

In Sliplane account settings, add your public SSH key.

Step 2 – Open the service console

In your Rails service, click Console / SSH. Sliplane provides a ready-to-copy SSH command.

Use that command.

Step 3 – Navigate to the app directory

cd /your-app

Step 4 – Run commands

bundle exec rails db:migrate
bundle exec rails db:seed
bundle exec rails c

---

💡 Migrate PostgreSQL DB from Heroku (Optional)

We assume:

• Heroku app has a Postgres addon

• Sliplane has an internal Postgres service (like postgres-lhlg.internal:5432)

• You can run commands locally (recommended)

---

Phase 1 — Freeze Heroku

1️⃣ Put Heroku in maintenance mode

heroku maintenance:on -a YOUR_HEROKU_APP

This prevents new writes while you migrate.

---

2️⃣ Take final backup (insurance)

heroku pg:backups:capture -a YOUR_HEROKU_APP
heroku pg:backups:download -a YOUR_HEROKU_APP

You now have latest.dump locally.

Keep it safe.

---

Phase 2 — Restore to Sliplane

(You already did this, but here’s the official version)

3️⃣ Use pg_restore 17 locally

PGPASSWORD='YOUR_DB_PASSWORD' $(brew --prefix postgresql@17)/bin/pg_restore \
  --verbose \
  --clean --if-exists \
  --no-owner --no-privileges \
  -h YOUR_PUBLIC_DB_HOST \
  -p YOUR_PUBLIC_DB_PORT \
  -U postgres \
  -d mydb \
  latest.dump

Let it finish.

---

4️⃣ Verify restore

PGPASSWORD='YOUR_DB_PASSWORD' psql \
  -h YOUR_PUBLIC_DB_HOST \
  -p YOUR_PUBLIC_DB_PORT \
  -U postgres \
  -d mydb \
  -c "\dt"

Then test row counts:

select count(*) from users;

Match with Heroku:

heroku run rails console -a YOUR_HEROKU_APP
User.count

If counts match → DB migration successful.

---

Phase 3 — Point Rails to Sliplane DB

Now update your Sliplane Rails service:

Use internal DB URL (important for security & performance):

postgresql://postgres:[email protected]:5432/mydb

Set this as:

DATABASE_URL

in Sliplane environment variables.

---

5️⃣ Redeploy Rails app

Then test:

• Login works

• New records save

• Background jobs work

• Stripe webhooks work

• Emails send

• ActiveStorage works

Create a test record and delete it.

---

Phase 4 — Switch Traffic

If not already done:

• Update DNS to Sliplane

• Wait propagation

• Confirm production domain works

Monitor logs for 10–15 minutes.

---

Phase 5 — Lock Down Database

Very important.

Once everything works:

• Remove public DB access

• Remove 0.0.0.0/0

• Make Postgres internal-only

Your Rails app should now talk only via internal hostname.

---

Phase 6 — Kill Heroku (After Confidence Window)

Leave Heroku in maintenance mode for a few hours (optional safety buffer).

When ready:

heroku apps:destroy -a YOUR_HEROKU_APP

Also remove:

• Heroku Postgres addon

• Heroku Redis

• Any scheduler addons

Double-check nothing else depends on it.

Cost Optimization Tip

You can host multiple Lightning Rails apps on the same Sliplane server.

Each app:

• Has its own Project

• Has its own Postgres service

• Shares the same server resources

This keeps infrastructure simple and affordable.

---

Summary

Deploying Lightning Rails to Sliplane is:

1. Run one setup command

2. Create server

3. Add Postgres

4. Add Repository service

5. Paste env variables

6. Deploy

Clean, simple, production-ready.