Deployment Guide: Dokploy, Orbita, VPS & Vercel

Deployment Options Overview

Grit apps can be deployed in multiple ways depending on your needs, budget, and technical comfort level. Here are the four methods you will learn:

Method 1: grit deploy (Direct VPS)

The simplest deployment method. One command builds your app, uploads it to your server, and configures everything automatically:

grit deploy --host deploy@server.com --domain myapp.com

Here's what grit deploy does behind the scenes:

• 1. Builds the Go binary — cross-compiles for Linux (your server's OS)
• 2. Uploads via SCP — securely copies the binary to your server
• 3. Creates a systemd service — so your app auto-restarts on crash or reboot
• 4. Configures Caddy — reverse proxy with automatic HTTPS (Lets Encrypt)
• 5. Starts the service — your app is live at your domain

Method 2: Dokploy

While grit deploy is a one-time push, Dokploy gives you a full deployment pipeline:

• • Git push to deploy — Dokploy watches your repo and auto-deploys on push
• • Web dashboard — manage apps, view logs, set environment variables from a browser
• • Docker-based — each app runs in an isolated container
• • Auto-SSL — HTTPS certificates managed automatically
• • Database management — spin up PostgreSQL, Redis, and more from the UI

To set up Dokploy on your VPS:

# Install Dokploy (one command)
curl -sSL https://dokploy.com/install.sh | sh

After installation, access the Dokploy dashboard at https://your-server-ip:3000. From there, connect your GitHub account, select your repository, and Dokploy handles the rest.

Dokploy Configuration

Dokploy uses Docker to build and run your app. Grit scaffolds a production-ready Dockerfile that uses multi-stage builds to keep the final image small:

# Stage 1: Build the Go binary
FROM golang:1.24 AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o server ./cmd/server

# Stage 2: Create a minimal runtime image
FROM alpine:latest
COPY --from=builder /app/server /server
EXPOSE 8080
CMD ["/server"]

For the full stack (API + database + Redis), use the production Docker Compose file:

version: '3.8'
services:
  api:
    build: .
    ports:
      - "8080:8080"
    env_file: .env
    depends_on:
      - db
      - redis
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: myapp
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pgdata:/var/lib/postgresql/data
  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data
volumes:
  pgdata:
  redisdata:

In Dokploy, you can configure environment variables through the web UI instead of managing.env files on the server. Set your database credentials, JWT secret, API keys, and other sensitive values securely through the dashboard.

Method 3: Orbita

Orbita is purpose-built for Grit's ecosystem. While Dokploy is a general-purpose PaaS, Orbita understands Grit conventions:

• • One-click deploy — connect your server, select a Grit project, deploy
• • Auto-SSL — HTTPS certificates managed automatically via Lets Encrypt
• • Environment management — configure production .env through the UI
• • Log viewing — stream application logs from the dashboard
• • Server management — manage multiple servers and apps from one place

The deployment flow with Orbita:

• 1. Install Orbita on your VPS (or use a separate management server)
• 2. Add your server's SSH credentials in the Orbita dashboard
• 3. Connect your GitHub repository
• 4. Configure environment variables and domain
• 5. Click Deploy — Orbita builds and ships your app

Orbita vs Dokploy

Both are self-hosted PaaS tools, but they serve slightly different purposes:

Method 4: Vercel (Frontend Only)

For Triple or Double architecture projects with a Next.js frontend, you can deploy the frontend to Vercel while keeping the Go API on your VPS. This gives you the best of both worlds — Vercel's CDN and edge network for the frontend, your own server for the API.

# Step 1: Deploy the Go API to your VPS
grit deploy --host deploy@server.com --domain api.myapp.com

# Step 2: Deploy the Next.js frontend to Vercel
cd apps/web && vercel

The critical configuration step: tell the Vercel-hosted frontend where to find your API. In Vercel's dashboard, set this environment variable:

NEXT_PUBLIC_API_URL=https://api.myapp.com

Advantages of the Vercel + VPS split:

• • Global CDN — frontend served from edge nodes closest to the user
• • Automatic previews — every PR gets a preview deployment URL
• • Zero-config — Vercel auto-detects Next.js and configures everything
• • Free tier — generous free plan for personal projects

DNS Configuration

After buying a domain, you need to point it at your server by creating DNS records in your domain registrar's dashboard (Namecheap, Cloudflare, GoDaddy, etc.):

Production Environment Variables

Your development .env file has placeholder values that are not safe for production. Before deploying, you need to update several critical variables:

# App
APP_ENV=production
APP_PORT=8080

# Database
DB_DRIVER=postgres
DB_HOST=localhost
DB_PORT=5432
DB_USER=myapp
DB_PASSWORD=<strong-random-password>
DB_NAME=myapp_production

# Auth
JWT_SECRET=<64-character-random-string>

# Storage
STORAGE_DRIVER=s3
S3_BUCKET=myapp-uploads
S3_REGION=us-east-1
S3_ACCESS_KEY=<your-access-key>
S3_SECRET_KEY=<your-secret-key>

# Email
RESEND_API_KEY=re_<your-real-key>
EMAIL_FROM=noreply@myapp.com

# Redis
REDIS_URL=redis://localhost:6379

Critical changes from development to production:

• • APP_ENV — set to production (disables debug logging, enables security headers)
• • JWT_SECRET — must be a long, random string (not "secret" or "changeme")
• • DB_PASSWORD — a strong, unique password (not "password")
• • STORAGE_DRIVER — switch from local to S3, R2, or B2 for persistent file storage
• • RESEND_API_KEY — your real Resend API key (development uses Mailhog)

SSL/TLS Certificates

The good news: you almost never need to manage SSL certificates manually. Each deployment method handles it automatically:

• • grit deploy — Caddy auto-provisions Lets Encrypt certificates
• • Dokploy — built-in Lets Encrypt support through the dashboard
• • Orbita — automatic SSL certificate management
• • Vercel — SSL included automatically for all deployments

Monitoring After Deployment

Deploying your app is only half the job. You also need to know when something goes wrong. There are two types of monitoring:

Recommended monitoring setup:

• • Pulse — built into Grit, shows response times, error rates, and active connections
• • UptimeRobot (free) — pings your health endpoint every 5 minutes, alerts on downtime
• • Better Stack (free tier) — uptime monitoring + incident management + status pages

Every Grit app has a health endpoint at /api/health that returns the app's status. Point your uptime monitor at this endpoint.

What You Learned

• Four deployment methods: grit deploy, Dokploy, Orbita, and Vercel
• How grit deploy builds, uploads, and configures your app in one command
• Dokploy as a self-hosted PaaS with Docker and auto-deploy
• Orbita as a Grit-native deployment platform
• Splitting frontend (Vercel) and API (VPS) deployment
• DNS configuration for domains and subdomains
• Production environment variables and security
• Automatic SSL with Lets Encrypt
• Monitoring with Pulse and uptime services