Deploy · self-host anything

Deploy any software to any cloud — or your customer’s.

Managed Kubernetes, GitOps that keeps every install in sync, and one versioned package per app. It runs in your cloud, on your cluster, with your keys.

Read the docs →

Self-hosting anything is a bespoke build every time.

A custom setup per customer; config that drifts between environments; a manual upgrade for every install — and no one notices the drift until something breaks at 2am.

Run the same app across AWS, Hetzner, and a customer’s on-prem rack, and you’re maintaining three variants of one thing. What you can run here is anything that runs on Kubernetes — your own product, or third-party software your platform team has to operate.

# the whole app — one versioned package
akua.toml     # intent + typed inputs
akua.lock     # resolved digests + signatures

How it works.

Package once, install anywhere, let GitOps keep it true.

  1. Package it once

    A versioned, signed release: akua.toml records intent, akua.lock records resolved digests and signatures. Your existing Helm charts are wrapped as-is — the package adds typed inputs around them; the chart itself is unchanged.

  2. Install it anywhere

    Get managed Kubernetes in minutes, or bring your own cluster. The customer picks the cloud; the package does not change.

  3. Let GitOps keep it true

    The platform renders each install into its own git repository, and Argo CD reconciles it. Updates land as a reviewed change, never a push straight to main.

You can run the render yourself — akua render is deterministic, and the rendered repository is the deploy artifact you can read, diff, and keep.

What you get.

  • Install

    Helm charts, without the values sprawl. Inputs are typed and validated up front.

  • Update

    Bump the version once; the platform proposes the change to every install.

  • Reconcile

    Drift is corrected automatically, so live state always matches the repository.

  • Roll back

    A revert of rendered state — not a guess at the last good inputs.

  • Observe

    Every install’s sync state and health in one view.

  • Export

    Standard manifests, your images, your cluster. Leave anytime — it keeps running with us or without us.

Run anywhere. Keep the exit.

AWS · Azure · GCP · Hetzner · IONOS · OVH · Scaleway · on-prem · your own.

  • KaaS — we run the control plane; your machines join as workers.
  • Bring your own cloud or machines — it runs in your account, on your credentials, never ours.

Take the export anytime: standard manifests, your container images, your cluster. It keeps running with us or without us.

Proof.

Code Zero ships its software onto customers’ own infrastructure this way — packaged once, installed into the customer’s cloud, kept in sync from one place.
And two clinical applications in Germany — one for the OR, one for general clinic operations — run the same model: patient data lives on the customer’s own servers, isolated per site.

Operate by intent.

Open the dashboard and say “why is this install failing.” An agent reads the install’s repository, its sync status, and its events, drafts a change, and asks for the same review a person would. Same git history, same approval gate — an agent can’t do anything a human couldn’t audit.

You own it.

Standard formats end to end, and a bill you can read. Nothing here is ours to hold over you.

Admin keys
Yours. Not ours, not shared, not escrowed.
Formats
Standard end to end — no proprietary lockfile you can’t read, no console you can’t leave.
Network
The install only ever connects outbound; nothing reaches in.
Billing
We charge for the platform. You pay your cloud provider directly. No markup on compute.

FAQ.

What do I have to run?

Bring your own cluster, or get a managed one. Your machines stay yours either way.

Does it take my existing Helm charts?

Yes. A package wraps what you already ship; its inputs become a typed setup screen.

On-prem?

Yes — the install runs on the customer’s own servers and only ever connects outbound; nothing reaches in. Fully air-gapped is an enterprise conversation — talk to the founders.

Why not just run Argo CD myself?

You can — and you’d own the rendering, the per-install repositories, the drift detection, and the upgrade choreography by hand. This is that, kept in sync, with the repository still yours to take.

What if you disappear?

Every install keeps running. The repository, the rendered manifests, and the credentials are already yours.

Deploy any software to any cloud,
and keep the keys.

One versioned package per app. Managed Kubernetes or your own cluster. The export stays yours the whole way down.

Read the docs