I've been building Frost https://github.com/elitan/frost, open source and self-hosted. Same idea, git push to deploy, automatic SSL, custom domains, but on your own VPS. Docker-native, no vendor lock-in, no pricing surprises.

The angle that's a bit different: it's designed for AI coding agents. Simple config they write correctly, clear errors, no K8s complexity to hallucinate. You give your agent the install URL and it sets up the whole server.

Stack: Bun, Next.js, SQLite, Kysely. Been building it almost entirely with Claude Code which has been a surprisingly effective workflow for this kind of infra tooling.

https://github.com/elitan/frost

What I've found: Claude Code is great at the "figure out this docker/nginx/systemd incantation" part but the orchestration layer (health checks, rollbacks, zero-downtime deploys) still benefits from purpose-built tooling. The AI handles the tedious config generation while you focus on the actual workflow.

github.com/elitan/frost if curious

Works with any PG version today. Each branch is a fully isolated PostgreSQL container with its own port. ~2-5 seconds for a 100GB database.

https://github.com/elitan/velo

Main difference from PG18's approach: you get complete server isolation (useful for testing migrations, different PG configs, etc.) rather than databases sharing one instance.

The core idea: use ZFS copy-on-write snapshots to branch PostgreSQL databases the way you branch Git repos. A 100GB database branches in ~2 seconds and takes ~100KB of space initially. Each branch is a complete, isolated PostgreSQL instance running in Docker.

How it works:

- Runs CHECKPOINT to flush PostgreSQL buffers (ensures consistency)

- Creates a ZFS snapshot (filesystem-level, instant)

- Clones the snapshot to a new dataset (CoW means no data copying)

- Spins up a new PostgreSQL container pointing at the clone

The mental model is: Project = Git repo, Branch = Git branch. Commands like `velo branch create api/test-migration` or `velo branch reset api/dev`.

I also added point-in-time recovery using WAL archiving, so you can create branches from specific timestamps (e.g., "5 minutes before the incident").

Requirements: Linux + ZFS + Docker.

Built using Bun and TypeScript.

Let me know what you think :)

Comments URL: https://news.ycombinator.com/item?id=45580008

Points: 3

# Comments: 3

* Velo - Postgres with instant branching (https://github.com/elitan/velo)

* Terra - Declarative schema management for Postgres (https://github.com/elitan/terra)

Some fun side projects i hack on during the evenings and weekends.

> A hybrid of Strong (the lifting app) and ChatGPT where the model has access to my workouts, can suggest improvements, and coach me. I mainly just want to be able to chat with the model knowing it has detailed context for each of my workouts (down to the time in between each set).

here: https://j4.coach/

Still early, have ~30 min per day to work on it but it's usable and improving every week :)

https://github.com/elitan/lightform/pull/35

One of the advantages of vibe coding CLI tools like this is that it's easy for the AI to debug itself, and it's easy to see where it gets stuck.

And it usually gets stuck because of:

1. Errors 2. Don't know what command to run

So:

1. Errors must be clear and *actionable* like `app_port` ("8080") is a string, expected a number. 2. The command should have simple, actionable and complete help (`--help`) sections for all commands.