Deploying to Your Own Server Shouldn't Be This Easy

Every solo developer hits the same wall: your side project works on localhost, and now you need it on the internet. The options are usually one of three things:

1. Vercel/Netlify — easy, but gets expensive fast once you need a database, cron jobs, or anything that isn't a static site.
2. A VPS with SSH — cheap, but you're one docker compose typo away from a 2am debugging session.
3. AWS/GCP — powerful, but the billing dashboard alone is a full-time job.

I've been through all three. Vercel for previews (still great for that). A VPS for production (cheap but fragile). AWS for one project (never again for a solo dev). Then I found Dokploy, and my deploy story changed completely.

What Dokploy actually is

Dokploy is an open-source, self-hosted deployment platform. Think of it as a self-hosted alternative to Vercel, Railway, or Render — but you run it on your own server. It gives you:

• A web dashboard to manage deployments
• Automatic SSL via Traefik (Let's Encrypt)
• Dockerfile, Nixpacks, or Docker Compose deployments
• Database management (Postgres, MySQL, MongoDB, Redis) with built-in backups
• Real-time monitoring (CPU, memory, network)
• Multi-server support
• API and CLI access

One command to install:

curl -sSL https://dokploy.com/install.sh | sh

That's it. You now have a deployment platform running on your VPS.

My deploy pipeline

Here's how I ship code now:

1. Push to GitHub — git push origin main
2. GitHub Actions builds a Docker image — pushes to GitHub Container Registry (GHCR) as ghcr.io/muhfauziazhar/<repo>:latest
3. Dokploy pulls and deploys — a webhook triggers Dokploy to pull the new image and restart the container
4. Traefik handles routing + SSL — automatic HTTPS, no nginx config, no certbot

The whole flow takes about 2-3 minutes from git push to live. No SSH. No manual docker commands. No "let me check if the container is running."

Why not just Vercel?

Vercel is great for frontend-heavy projects. I still use it for preview deployments. But for production, I kept running into walls:

• Database: Vercel doesn't host databases. You need Supabase, Neon, or PlanetScale — another service, another bill.
• Background jobs: Vercel's serverless functions have a 10-second timeout. Cron jobs, queue workers, and long-running processes don't fit.
• Cost: Once you need more than a hobby project, Vercel Pro is $20/month per team member. A VPS with Dokploy is $5-10/month total.
• Control: With Dokploy, I own the server. I can SSH in, check logs, run migrations, install system packages. With Vercel, you're on their runtime, their limits, their rules.

The tradeoff is you manage the server. But Dokploy makes that management 90% easier.

What the dashboard gives you

Dokploy's web UI lets you:

• Deploy apps from Dockerfile, Nixpacks, or Docker Compose
• Manage databases — create a Postgres instance in 2 clicks, with automatic backups
• Set environment variables — per-app, with a clean UI (no .env file juggling)
• View logs — real-time container logs, no docker logs -f in terminal
• Monitor resources — CPU, memory, network per app
• Configure domains — point your domain, Dokploy handles Traefik + SSL automatically
• Manage users — if you have a team, role-based access

For a solo developer, the killer features are one-click deploys and automatic SSL. I used to spend 30 minutes configuring nginx and certbot for each new domain. Now it's 30 seconds.

The GHCR + webhook pattern

My preferred deploy pattern uses GitHub Container Registry as the image store and Dokploy's webhook for triggering deploys:

GitHub repo
  → GitHub Actions: docker build + push to ghcr.io/<user>/<repo>:latest
  → Webhook call to Dokploy API
  → Dokploy: docker pull + restart container

Why GHCR over Docker Hub? GitHub Actions has native GHCR authentication (no extra secrets), and GHCR has generous free storage for public repos. Docker Hub's rate limits have burned me before.

The webhook pattern means I can trigger deploys from anywhere — CI/CD, a cron job, even a curl command. It's just an HTTP POST.

What it costs

My setup:

• VPS: 2 vCPU, 4GB RAM, 80GB SSD — ~$10/month (Hetzner/Contabo)
• Dokploy: Free, open source
• GHCR: Free for public repos
• Domain: ~$10/year
• SSL: Free (Let's Encrypt via Traefik)

Total: ~$11/month for hosting unlimited apps with databases, SSL, monitoring, and backups. Compare that to Vercel Pro ($20/month) + Neon ($19/month) + any other SaaS you'd need.

The gotchas

It's not all smooth:

• You manage the server. OS updates, security patches, disk space — that's on you. Dokploy makes deployments easy, but it doesn't make you a sysadmin.
• Backups need setup. Dokploy has built-in backup support, but you need to configure where they go (S3, external storage). Don't skip this.
• Single point of failure. If your VPS goes down, everything goes down. For a portfolio or side project, this is fine. For a business-critical app, you'd want multi-server.
• Community-driven. Dokploy is open source with 34k+ stars and active development, but it's not a billion-dollar company. Docs can lag behind features.

Who this is for

Dokploy is perfect if you're:

• A solo developer or small team running side projects
• Someone who wants production-grade deploys without production-grade costs
• Comfortable with basic server management (SSH, Docker basics)
• Tired of paying per-app for platforms like Railway or Render

It's probably not for you if:

• You need 99.99% uptime SLA (get a managed platform)
• You've never touched a terminal (start with Vercel, graduate to Dokploy later)
• Your team is 10+ people (at that point, the ops overhead matters less than the platform features)

The bottom line

Dokploy turned my deploy workflow from "SSH into server, pull, build, pray" into a 3-button web UI. It's not perfect, and it's not for everyone. But for a solo developer who wants control without the overhead, it's the best $0 tool I've found.

I run 8 apps on one $10 VPS. Each has its own domain, SSL, database, and monitoring. Deploys take 2-3 minutes. I haven't SSH'd into the server for a deploy in months.

That's the workflow now. Push code, get a URL. The boring parts are handled.