[ PIER ]
Lightweight self-hosted PaaS in Rust — an alternative to Coolify, Heroku and Vercel. Single binary running on 20–40 MB RAM, deploys containers, Docker Compose stacks and Git repos, automatic HTTPS via Traefik, multi-server management and embedded SQLite. Runs on a $5 VPS.
![[ PIER ]](/_next/image?url=%2Fimages%2Fprojects%2Fpier.webp&w=3840&q=75)
Challenge
Coolify offers Heroku-like deployment but eats 750 MB – 1.2 GB of idle RAM and runs 6+ containers (Laravel, PostgreSQL, Redis, Soketi, Horizon, Traefik). Too heavy for small projects and self-hosting on a cheap VPS — needs at least 2 GB RAM and 2 vCPU.
Solution
A single Rust binary running on 20–40 MB RAM with embedded SQLite and a ~30 KB HTMX frontend. Same features (Docker, Compose, Git-to-deploy, Let's Encrypt SSL, multi-server, S3 backups) in a 30× smaller footprint. No separate database, no extra containers — just Traefik.
Result
Runs on a $5 VPS (512 MB RAM, 1 vCPU). Takes 15–30 MB of disk vs ~1 GB for Coolify. Open-source under AGPL-3.0, available on GitHub. Version 1.0.2 in production.
About the platform
PIER is an open-source alternative to Coolify, Heroku and Vercel for self-hosting. A PaaS-grade platform that runs on any Linux server: from a Raspberry Pi or homelab NUC to a $5/month VPS. Under the hood — a single binary written in Rust, with no external dependencies like PHP, Node.js or PostgreSQL.
The goal is to give developers and small teams a tool that makes deploying Docker containers, Docker Compose stacks and Git repositories as fast as commercial PaaS — but without vendor lock-in, subscription fees or opaque infrastructure. PIER handles SSL certificates, reverse proxy, automatic rollback, S3 backups and real-time resource monitoring out of the box.
The codebase is fully open under AGPL-3.0 and available on GitHub. The architecture is built for long-term operation: embedded SQLite removes the need for a separate database server, and a single binary with rust-embed bundles all templates, migrations and static assets — upgrading is just copying one file and restarting a systemd unit.
Compared to alternatives
An honest comparison of PIER with the three most popular self-hosted PaaS options: Coolify, Dokku and CapRover. Numbers are taken from official documentation and real measurements on a fresh Ubuntu 24.04 install.
| Metric | PIER | Coolify | Dokku | CapRover |
|---|---|---|---|---|
| Idle RAM | 20–40 MB | 750 MB – 1.2 GB | ~120 MB | ~250 MB |
| Disk footprint | 15–30 MB | ~1 GB | ~150 MB | ~400 MB |
| Idle containers | 1 (+ Traefik) | 6+ | 0 | 5+ |
| Minimum VPS | 512 MB / 1 vCPU | 2 GB / 2 vCPU | 1 GB / 1 vCPU | 1 GB / 1 vCPU |
| Implementation language | Rust | PHP / Laravel | Bash / Go | TypeScript / Node.js |
| Frontend size | ~30 KB | ~300+ KB | no UI | ~500+ KB |
| Database | Embedded SQLite | External PostgreSQL | Filesystem | Embedded LokiJS |
| License | AGPL-3.0 | Apache 2.0 | MIT | Apache 2.0 |
Features
Docker containers
Create, start, stop, restart, logs and stats via bollard. Full container control from the web UI.
Compose stacks
Built-in YAML editor for managing multi-service stacks. Deploy a docker-compose.yml in one click.
Git-to-deploy
GitHub and GitLab webhooks, build from Dockerfile, image or Compose. Deployment history with rollback.
Reverse proxy
Traefik with automatic HTTPS via Let's Encrypt. Custom domains and auto-generated service URLs.
Multi-server
Manage multiple servers via remote agents. One UI — many servers, many regions.
S3 backups
Scheduled snapshots with any S3-compatible storage. AWS, Backblaze, MinIO, any S3 API.
Monitoring
Real-time CPU, RAM, disk and network — without a separate Prometheus or Grafana. All in one binary.
30+ templates
PostgreSQL, MySQL, MongoDB, Redis, Grafana, Gitea, Matrix, Minecraft, AmneziaWG and more — one-click deploy.
Architecture
PIER is built around minimalism: all business logic, UI templates, DB migrations and static assets are bundled into a single Rust binary. No separate services, queues or brokers — just PIER itself and Traefik for reverse proxy.
Backend — Rust + Tokio + Axum
Async HTTP server built on Axum on top of Tokio. Tower middleware handles CORS, compression, static files and tracing. Concurrency comes free — without green threads, GC pauses, or extra memory per worker.
Storage — Embedded SQLite (rusqlite)
The database is bundled into the binary via rusqlite with the `bundled` feature. Online backups are supported. No external PostgreSQL, no access rights, passwords or network connections to a database — everything is local, in a single file.
Frontend — HTMX + Alpine.js + Tailwind
UI is rendered server-side via MiniJinja templates and updated through partial HTMX requests. Alpine.js handles local interactivity. Result: ~30 KB of JavaScript per page versus hundreds of KB in SPA equivalents.
Containers — bollard
Docker daemon is managed via bollard — the official Rust client for the Docker API. Create, start, stop, logs, stats, file copy into containers — all through a native async API without shell wrappers.
Proxy — Traefik + Let's Encrypt
Traefik reverse proxy automatically picks up Docker labels and provisions HTTPS via Let's Encrypt. PIER writes the right labels on deploy — the user configures nothing manually.
Security — JWT + bcrypt + AES-GCM
Authorization via JWT, passwords hashed with bcrypt, environment secrets encrypted with AES-GCM before being written to the DB. GitHub and GitLab webhook signatures are verified with HMAC-SHA256.
Built-in templates
Over 30 pre-configured templates for one-click deployment. Each template is a validated docker-compose.yml with proper volumes, healthchecks, and environment variables.
Databases
PostgreSQL, MySQL, MariaDB, MongoDB, Redis, Valkey, ClickHouse, Cassandra, ScyllaDB, Qdrant
Services
Grafana, Gitea, Forgejo, Matrix Synapse, Elasticsearch, Kibana, RabbitMQ, Directus, Supabase, NocoDB, Portainer, Gotify, Audiobookshelf, Beszel
Game servers
Minecraft, Terraria
VPN
AmneziaWG
Who it's for
PIER is optimised for scenarios where heavy self-hosted PaaS like Coolify is overkill, or simply doesn't fit on the available server.
Indie developers and freelancers
A single $5/month server can host 5–10 SaaS projects, landing pages and pet projects. No need to pay Heroku, Render or Fly.io subscriptions per service.
Side projects on a cheap VPS
PIER runs on 512 MB of RAM. That means Hetzner Cloud CX11, Oracle Free Tier ARM or DigitalOcean nanode are perfectly capable of running dozens of containers with automatic SSL.
Homelab and self-hosting
Ideal for home labs: Raspberry Pi 4, Intel NUC, mini-servers. Minimal CPU and RAM overhead leaves resources for the containers the server actually exists for.
Agencies and small teams
Deploy client projects without vendor lock-in. PIER installs on any client server — from bare metal in their own server room to a VPS at any provider that supports Linux.
Frequently asked questions
How is PIER different from Coolify?
The main difference is footprint. Coolify is built on PHP/Laravel and consumes 750 MB – 1.2 GB of idle RAM, running 6+ containers (Laravel, PostgreSQL, Redis, Soketi, Horizon, Traefik). PIER is a single Rust binary using 20–40 MB of RAM with embedded SQLite. Both cover container, Compose stack and Git deployments, SSL and multi-server. Coolify ships with more integrations out of the box; PIER is lighter and faster on cheap VPSes.
Can I use PIER instead of Heroku or Vercel?
Yes, for most scenarios. PIER provides Git-to-deploy via GitHub and GitLab webhooks, automatic HTTPS through Let's Encrypt, custom domains and rollback to previous versions. What's missing — Heroku-grade managed databases and Vercel-grade edge functions: in exchange you handle the server yourself.
What are the minimum server requirements?
512 MB of RAM, 1 vCPU and Linux with Docker support (Ubuntu 22.04+, Debian 12+). On those resources PIER comfortably handles 5–15 user containers. For serious workloads 1 GB of RAM is recommended.
Is PIER production-ready?
Yes — version 1.0.2 is used in production. The platform supports scheduled S3-compatible backups, real-time resource monitoring and deployment rollback. For mission-critical systems we recommend deploying PIER on two servers with regular SQLite-file replication via S3.
How does PIER manage SSL certificates?
Through Traefik and Let's Encrypt. When you deploy a service, PIER writes Docker labels that Traefik picks up automatically and requests a certificate via the ACME challenge. Custom domains are configured in one click from the web UI — just point an A-record at the server IP.
Can I deploy from a private GitHub repository?
Yes. PIER supports GitHub apps with webhook authorization and deploy-key access. The same works for GitLab — private projects connect via a personal access token with read permissions.
What license is PIER distributed under?
AGPL-3.0. This means PIER can be used for free for both personal and commercial purposes — including hosting client projects. If you build your own SaaS service on top of PIER (i.e. offer PIER itself as a service), the source code of your version must be open to users under the same license.