GUI app to deploy Docker apps to VPS in minutes without knowing command lines

ServerCompass 1.2.0: Deploy Docker Apps to Your VPS in Minutes, Not Hours

The days of SSHing into servers to manually deploy applications are over.

Today, we're releasing ServerCompass 1.2.0 with a feature we've been building for months: Deploy New App – a visual wizard that lets you deploy Docker applications to your VPS without touching the command line.

No more juggling SSH terminals. No more debugging port conflicts in production. No more wondering if your deployment actually worked.

Just point, click, and deploy.

The Problem: VPS Deployment Shouldn't Be This Hard

If you've ever deployed an application to a VPS, you know the drill:

1. SSH into your server

2. Install Docker (if not already installed)

3. Create a directory for your app

4. Write a docker-compose.yml file (or copy-paste from the last project)

5. Create a Dockerfile (if you need custom builds)

6. Set up environment variables in a .env file

7. Run docker compose up -d

8. Wait... and hope nothing fails

9. Realize port 3000 is already in use

10. Debug for 20 minutes

11. Try again

For a simple Next.js app, this process takes 30-60 minutes. And that's if everything goes right.

What if your VPS only has 512MB RAM? Building a Next.js app will likely fail with out-of-memory errors. You'll need to either upgrade your server or build locally and push the image manually.

This is the reality for thousands of developers deploying side projects, client work, and production apps to VPS instances.

The Solution: Deploy New App Wizard

ServerCompass 1.2.0 introduces a 5-step visual wizard that handles the entire deployment process for you:

1. Choose Your Source

Deploy from anywhere:

• GitHub Repository – Connect your repo, select a branch, and deploy

• Container Registry – Pull images from DockerHub, GHCR, GitLab, or private registries

• Pre-built Templates – WordPress, PostgreSQL, Redis, Nginx, and more

• Paste YAML – Already have a docker-compose.yml? Paste it in

• Upload Files – Drag and drop your local project folder

2. Configure Your App

The wizard walks you through:

• Project naming

• Port configuration (with automatic conflict detection)

• Docker Compose editing with real-time validation

• Environment variables

• Build settings

3. Choose Where to Build

Here's where it gets interesting.

Option 1: Build on VPS (Traditional)

• Docker images build directly on your server

• Good for small apps and powerful VPS instances

• No external dependencies

Option 2: Build with GitHub Actions (New!)

• Docker images build on GitHub's infrastructure

• Pushed to GitHub Container Registry

• Your VPS only pulls and runs the final image

• Perfect for small VPS instances that can't handle large builds

We'll dive deeper into GitHub Actions build in a moment – it's our favorite feature.

4. Review & Deploy

Before deployment, ServerCompass shows you:

• ✅ Ports being used (with conflict detection)

• ✅ Services being created

• ✅ Environment variables

• ✅ Resource requirements

If there are any issues (port conflicts, invalid YAML, missing SSH keys), you'll know before the deployment fails.

5. Watch It Happen

Once you hit "Deploy", you'll see:

• Real-time deployment logs

• Current deployment phase (Pulling images → Building → Starting containers)

• Progress percentage

• Success/failure status

No more "is it working?" uncertainty. You'll know exactly what's happening and when it's done.

GitHub Actions Build: The Game-Changer

This is the feature we're most excited about.

The Problem with Small VPS Instances

A $4/month VPS with 512MB RAM is perfect for running applications. But building them? That's a different story.

Try building a Next.js app with dependencies on a 512MB server:

$ docker compose build
...
npm install
# 10 minutes later
Killed

Out of memory. Your build fails.

Your options:

1. Upgrade to a more expensive VPS

2. Build locally and push images manually

3. Use a CI/CD service (complex setup)

Or use ServerCompass with GitHub Actions build.

How It Works

When you select "Build with GitHub Actions", ServerCompass:

1. Generates an optimized GitHub Actions workflow

   • Builds your Docker image on GitHub's runners (2-core CPU, 7GB RAM)

   • Pushes to GitHub Container Registry (free, unlimited public images)

   • SSHs into your VPS

   • Pulls the pre-built image

   • Starts the containers

2. Sets up SSH keys automatically

   • Generates an ed25519 key pair

   • Adds the public key to your VPS

   • Stores the private key as a GitHub Secret

   • No manual configuration required

3. Configures GitHub Secrets

   • VPS host, port, username

   • SSH private key

   • GitHub Container Registry credentials

   • All encrypted with libsodium sealed boxes

4. Triggers the first deployment

   • Workflow runs automatically

   • You watch the build progress in real-time

   • Logs streamed directly to ServerCompass

The Result

Your $4/month VPS can now run applications it could never build.

• Build time: 3-5 minutes on GitHub's infrastructure vs 20+ minutes (if it doesn't crash) on a small VPS

• VPS resource usage during build: 0% (vs 100% CPU, 95%+ memory)

• Automatic deployments: Push to your branch → GitHub builds and deploys automatically

Plus, you get:

• Build history on GitHub

• Cached builds (faster subsequent deployments)

• CI/CD out of the box

• Ability to review builds before they deploy

Port Conflict Detection: Stop Failures Before They Happen

One of the most frustrating deployment failures:

$ docker compose up -d
Error: bind: address already in use

You SSH in, run netstat -tuln, grep for the port, find what's using it, change your config, try again.

ServerCompass detects port conflicts before deployment.

When you reach the Review step, ServerCompass scans your server for:

• Docker containers using ports

• PM2 processes listening on ports

• Database services (PostgreSQL, MySQL, Redis)

• System services (nginx, Apache)

If your app wants to use port 3000 and it's already taken, you'll see:

⚠️ Port Conflict Detected

Port 3000: Docker Container
my-other-app_web (nginx:latest)

Suggestion: Use port 3001 instead

You can fix the conflict before deployment fails. No wasted time debugging in production.

Smart Framework Detection

Don't have a Dockerfile? No problem.

If you deploy a GitHub repository without a Dockerfile, ServerCompass:

1. Reads your package.json

2. Detects the framework (Next.js, React with Vite, Vue, or generic Node.js)

3. Generates an optimized Dockerfile automatically

For a Next.js app, it creates:

FROM node:18-alpine

WORKDIR /app

Copy package files

COPY package*.json ./

Install dependencies (auto-detects npm/yarn/pnpm)

RUN if [ -f yarn.lock ]; then yarn install --frozen-lockfile;
elif [ -f package-lock.json ]; then npm ci;
else npm install; fi

Copy application code

COPY . .

Build application

RUN npm run build

EXPOSE 3000

CMD ["npm", "start"]

Optimized for:

• Layer caching (dependencies cached separately)

• Production builds

• Minimal image size

• Security (non-root user)

Real-World Examples

Example 1: Deploying a Next.js Side Project

Before ServerCompass:

# SSH into VPS
ssh [email protected]

Create directory

mkdir -p /var/www/my-app
cd /var/www/my-app

Clone repo

git clone [email protected]:me/my-app.git .

Create Dockerfile (if not exists)

nano Dockerfile

... write Dockerfile ...

Create docker-compose.yml

nano docker-compose.yml

... write compose file ...

Create .env

nano .env

... add environment variables ...

Build (hope it doesn't OOM)

docker compose build

... wait 15-20 minutes ...

Start

docker compose up -d

Check if it's actually running

docker compose ps
curl localhost:3000

Total time: 45-60 minutes (if everything goes right)

With ServerCompass:

1. Click "New App"

2. Select "GitHub Repository"

3. Choose your repo and branch

4. Select "Build with GitHub Actions"

5. Review and deploy

Total time: 5 minutes (mostly waiting for GitHub to build)

Example 2: Deploying from a Template

Need a PostgreSQL database?

Before ServerCompass:

ssh root@vps
mkdir -p /var/www/postgres-db
cd /var/www/postgres-db
nano docker-compose.yml

... copy-paste from postgres docs ...

nano .env

... set POSTGRES_PASSWORD ...

docker compose up -d

With ServerCompass:

1. Click "New App"

2. Select "Templates"

3. Choose "PostgreSQL"

4. Set password and port

5. Deploy

Total time: 60 seconds

Example 3: Client Project with Custom Registry

Before ServerCompass:

ssh root@client-vps
docker login registry.gitlab.com

... enter credentials ...

cd /var/www/client-app
nano docker-compose.yml

... configure to pull from private registry ...

docker compose pull
docker compose up -d

With ServerCompass:

1. Add container registry credentials (one-time)

2. Click "New App"

3. Select your registry

4. Paste docker-compose.yml

5. Deploy

Total time: 2 minutes

Environment Variable Management

Environment variables are stored securely and synced automatically:

• Database storage: Variables saved in encrypted SQLite database

• VPS sync: Automatically creates .env files on your server

• Build-time variables: For Next.js, .env is copied to build context so NEXT_PUBLIC_ variables are baked into the bundle

• Runtime variables: Injected via env_file directive in docker-compose.yml

When you update environment variables:

1. ServerCompass updates the database

2. Syncs .env to your VPS

3. Prompts you to rebuild (required for build-time variables like NEXT_PUBLIC_)

4. Rebuilds images and restarts containers

No more SSH-ing in to edit .env files manually.

Real-Time Deployment Tracking

Every deployment shows:

• Current phase: Initializing → Preparing → Pulling Images → Building → Starting Containers → Running

• Progress percentage: Estimated based on typical deployment times

• Live logs: See exactly what's happening

• Error messages: If something fails, you'll know why

For GitHub Actions builds, you also see:

• Build job status: Queued → Building → Complete

• Deploy job status: Deploying → Complete

• GitHub Actions logs: Stream build logs directly to ServerCompass

• Link to GitHub: Click to view full workflow run

Redeploy Made Simple

Need to update your app? Click "Redeploy" and choose:

• Pull latest code (for GitHub repos)

• Rebuild images (apply environment variable changes)

• Force recreate containers (ensure fresh start)

ServerCompass handles the rest:

# For GitHub repos
git pull origin main
docker compose build --no-cache
docker compose up -d --force-recreate

For non-GitHub sources

docker compose build --no-cache
docker compose up -d --force-recreate

For GitHub Actions builds, redeploy triggers a new workflow run automatically.

Security Features

Credential Encryption

All sensitive data is encrypted:

• SSH passwords: AES-256-GCM encryption

• SSH private keys: Stored in credential vault

• Container registry credentials: Encrypted at rest

• GitHub tokens: Encrypted with libsodium sealed boxes

SSH Key Management

For GitHub Actions deployments:

• Ed25519 key pairs generated locally

• Private keys never stored in ServerCompass

• Private keys uploaded to GitHub Secrets (encrypted by GitHub)

• Public keys added to VPS and GitHub account

• Keys scoped per-app (one compromised key doesn't affect others)

Least Privilege

• SSH connections use specific credentials per server

• GitHub tokens scoped to required permissions only

• Container registry credentials isolated per deployment

What's Coming Next

We're actively working on:

• Multi-environment support: Deploy to staging and production with different configs

• Rollback functionality: One-click rollback to previous deployment

• Health checks: Monitor container health and auto-restart failures

• Volume management UI: Manage persistent data without SSH

• Advanced build configuration: Custom build commands, Node version selection, build arguments

• Deployment templates marketplace: Share and discover deployment configurations

Technical Details

For the curious:

Architecture:

• Desktop app: Electron + React

• Database: SQLite (better-sqlite3)

• SSH execution: ssh2 library

• Container orchestration: Docker Compose v2

• CI/CD: GitHub Actions

• Container registry: GitHub Container Registry (GHCR)

System requirements:

• macOS 10.15+, Windows 10+, or Linux

• VPS with Docker support (auto-installs if missing)

• SSH access to VPS (root or Docker group)

Supported VPS providers:

• DigitalOcean, Linode, Vultr, Hetzner

• AWS EC2, Google Cloud Compute

• Any VPS with SSH access

Pricing

ServerCompass is free for personal use.

We'll be introducing paid tiers for teams and commercial use in the future, but we're committed to keeping the core functionality free for individual developers and side projects.

Get Started Today

Ready to stop manually deploying to VPS?

Download ServerCompass 1.2.0:

• macOS (Apple Silicon)

• macOS (Intel)

• Windows

• Linux (AppImage)

Quick Start:

1. Download and install ServerCompass

2. Add your VPS (SSH credentials)

3. Click "New App"

4. Follow the wizard

5. Watch your app deploy in real-time

Need help?

• Documentation

• GitHub Issues

• Discord Community

Final Thoughts

We built ServerCompass because we were tired of spending evenings debugging VPS deployments instead of building features.

The Deploy New App feature represents hundreds of hours of work to make VPS deployment as simple as deploying to Vercel or Netlify – but with the control and cost-effectiveness of managing your own servers.

Whether you're deploying side projects to $4/month VPS instances or managing client applications across multiple servers, ServerCompass helps you focus on building, not infrastructure.

Try it out and let us know what you think. We read every piece of feedback and use it to guide development.

Happy deploying!

About the Author

ServerCompass is built by developers who've spent too many hours SSHing into servers. We believe VPS deployment should be visual, reliable, and accessible to developers of all experience levels.

Follow us on Twitter for updates and deployment tips.