Deployik

A single-binary, self-hosted platform-as-a-service in Go — blue-green deploys, auto-SSL, AES-256-GCM secrets — fronted by a TypeScript MCP server of ~90 tools so an agent can run the whole deploy / diagnose / screenshot loop in natural language. The site you're reading deploys on it.

The problem

Self-hosting a handful of small apps means stitching Docker, nginx, certificates, and secret storage together by hand — and then babysitting every deploy. I wanted the convenience of a managed PaaS without renting one: one box I own, one binary, no control plane I can't read.

The deeper problem was operational. Most platforms expose a dashboard built for a human with a mouse. I wanted infrastructure an agent could actually operate, which means a clean, typed surface for every action — not a UI to be clicked through or scraped.

So Deployik is two things at once: a PaaS I run my own projects on, and a deliberately machine-drivable substrate. The site you're reading is deployed on it.

The platform

Deployik ships as a single Go binary. The backend embeds the React dashboard via go:embed, so the whole platform — API, scheduler, UI — is one container with nothing to assemble. A substantial Go codebase across many internal packages — one shippable artifact.

It takes a GitHub repo and runs it as a Docker container behind nginx-proxy. Deploys are blue-green: the new release comes up, gets health-checked, and only then takes traffic — a bad build never replaces a good one. TLS is automatic via Let's Encrypt, and secrets are encrypted at rest with AES-256-GCM.

The dashboard is auth-gated — this is infrastructure, not a public toy. It surfaces releases, logs, domains, and the state of every running service. But the interesting part is what sits on top of it.

Agents drive it

Every platform action is also exposed through a TypeScript MCP server — roughly 90 tools over the Go core. That turns "deploy", "what's broken", and "show me the logs" into things an agent does in natural language, not buttons a human clicks.

A handful of high-level workflow tools do the heavy lifting: deploy_app_and_wait blocks until the release is actually live, whats_broken and debug_failed_deployment triage a failed build, and get_deploy_screenshot renders the running site so the agent can see its own result. Rollback, setting env vars, adding a domain — all of it is callable.

The effect is a closed loop an agent runs end to end: ship a branch, watch the blue-green swap, read the logs if it fails, diagnose, fix, redeploy, and screenshot to confirm — without a human touching the UI. The MCP layer is TypeScript wrapping the Go core, which is the honest shape of it: a small, typed agent surface over a self-contained platform I own.