XRAPH/Work/Instance lifecycle
Go · since 2026

Ctrlplane

Provisions and manages per-tenant instances on whatever you already run: Docker, Kubernetes, ECS or Fly. Rolling, blue-green and canary strategies, health checks over HTTP, TCP, gRPC or a command, custom domains and certificates, per-tenant quotas, and an audit trail of every action.

Language
Go
Category
Instance lifecycle
Since
2026
Stars
1
Repository Docs
01

Highlights

3 claims
H.01
Alibrary
Packages you import

Go packages you import. There is no binary to deploy and no runtime of its own to keep alive.

H.02
Sixproviders
One interface

Kubernetes, Docker, AWS ECS, Fly.io and Nomad, or your own, without the calling code knowing which.

H.03
Dayone
Multi-tenant

Every store query is scoped, every resource is quota-tracked and every action is audit-logged from the beginning.

02

What it does

7 entries

Provisioning and lifecycle for tenant instances, as packages you import into your own binary.

02.1
Lifecycle

A declarative state machine

Provision, start, stop, scale and destroy are transitions on a state machine, so an instance has a state you can read instead of one you infer.

Declarative
02.2
Deploys

Rolling, blue-green and canary

Three strategies that ship without dropping a request, chosen per deployment.

Zero downtime
02.3
Providers

Kubernetes to Fly.io

Infrastructure sits behind one interface, so Docker in development and Kubernetes in production is a configuration change.

Six targets
02.4
Health

Four kinds of check

HTTP, TCP, gRPC and command checks, with automatic recovery and a status the rest of the system can read.

Recovery
02.5
Networking

Domains and certificates

Custom domains with automatic TLS, route management and traffic splitting between versions.

TLS
02.6
Secrets

Injected at deploy

A pluggable vault interface holds the values and the deploy injects them as environment variables, so nothing is baked into an image.

Pluggable
02.7
Events

A bus for lifecycle hooks

Publish and subscribe over in-memory, NATS or Redis, so other systems learn about an instance changing state without polling for it.

NATSRedis
03

Anatomy

3 modules
01

Instances

Lifecycle of a tenant’s running instance, start to teardown.

02

Placement

Where an instance runs and what it is allowed to reach.

03

State

Desired versus observed, reconciled continuously.

04

Why it exists

Design notes

#What it is

Ctrl Plane deploys and manages SaaS instances at scale. You bring a cloud provider and an auth system; it handles instance lifecycle, deployments, health monitoring, secrets, traffic routing and tenant isolation.

It is a library rather than a framework: Go packages configured with functional options and embedded in your own application, standalone or as a Forge extension.

#What it does

  • Provisions tenant instances across any provider: Docker, Kubernetes, AWS ECS, Fly.io.
  • Deploys with rolling, blue-green, canary or recreate strategies.
  • Runs HTTP, TCP, gRPC and command-based health checks.
  • Manages custom domains, TLS certificates and traffic routing.
  • Stores secrets behind a pluggable vault backend.
  • Publishes lifecycle events and delivers webhooks.
  • Collects metrics, logs, traces and resource snapshots.
  • Enforces per-tenant quotas and records an audit trail.

#Where it came from

Every multi-tenant product I have built eventually grew a home-made version of this: a table of instances, a deploy script, a health poller, and a page in the internal admin. Ctrl Plane is that, extracted and made provider-agnostic before it grew a fifth incompatible implementation.

05

Signals

GitHub
Stars
1
Language
Go
Since
2026
Adopters
00

Shipping something on Ctrlplane? Nobody is listed here yet. Tell me what you built and you will be the first.

Get listed
06

Where it sits

Fields · papers