SAMOURAÏ COOPCase study · Engineering
Greffon
Self-host your sovereign apps in one click.
Client
Samouraï Coop — our own product
Crew
Engineering
Scope
Control plane · Worker agent · Open-source catalogue
Stack
Django · FastAPI · Docker · Nginx
01
The ask
Deploying an application means choosing between two poles, and most teams live between them.
Managed platforms democratised deployment at the price of metered bills, imposed terms and no say over where data lives. Kubernetes is the industry standard for good reasons, and a multi-year operational commitment for teams that should be shipping features. The gap between them is where organisations with data-residency, compliance or budget constraints actually sit.
02
The why
Self-hosting is not nostalgia. It is a position on who owns the pipeline.
Samouraï Coop builds and promotes open-source culture, and the engineering studio treats “who controls the infrastructure” as a design constraint rather than an afterthought. An organisation should own its deployment pipeline the way it owns its code. Greffon is that conviction made operable — the same position the coop takes on its own tools, offered to everyone else.
03
The constraint
It had to be operable by teams with no platform group to staff.
No Helm charts, no admission controllers, no ingress DSL — Docker Compose and a declarative configuration schema. Any Linux box qualifies as a node: bare metal, VM or cloud instance. The constraint was not “make it powerful”, it was “make it something a small team can run on the hardware it already has”.
04
How we built it
One control plane, any number of worker nodes, no vendor in the loop.
The manager backend is a Django control plane: it holds the catalogue of deployable applications, authenticates users, orchestrates instance lifecycle, and issues certificates through a built-in certificate authority — no external secrets manager to bootstrap first. Each greffer is a lightweight FastAPI agent on one of your nodes. It registers over a secure handshake, installs mTLS certificates for every exchange that follows, renders the Docker Compose template with Jinja2, creates volumes and networks, fronts the stack with a per-instance Nginx TLS proxy, and reports health back asynchronously. Greffers are cattle, not pets: the manager holds the configuration, so a dead node means the instance restarts elsewhere.
- Source:greffon.io ↗
- Source:github.com/greffon/greffer ↗
05
What we shipped
Beta, live, and open exactly where openness counts.
Greffon runs in beta at greffon.io. Two components are public: greffer, the worker agent, in Python and FastAPI under AGPL-3.0 — network copyleft, so hosted derivatives stay open while self-hosted use is unrestricted; and greffon-catalog, the example application templates, in TypeScript under Apache-2.0 so templates can be reused anywhere without friction. The licensing split is intentional: strong copyleft where the platform’s value lives, permissive where adoption should be effortless.
06
What happened
The core is stable. The platform hardens in the open.
The first milestone closed the reliability of the core — Django control plane, built-in CA, a stable orchestration API — and that is where the beta stands. The greffer’s migration to FastAPI unlocked async operation and WebSocket support; next come step-ca and Let’s Encrypt integration, reverse tunnelling for greffers behind NAT, and structured observability. Each milestone closes real operational gaps before the next one opens.
- Adoption figures and a named user quote — awaiting
