ANAKIN

Run your PaaS on any cloud.
No vendor lock-in.

Save 60% vs Heroku. Own your infrastructure. 100% open source.

                    # Deploy your app in seconds
kubectl apply -f -  <<EOF
apiVersion: anakin.dev/v1alpha1
kind: Project
metadata:
  name: my-app
spec:
  gitURL: https://github.com/user/app
  framework: nodejs
EOF
                

Why existing PaaS platforms fail

Heroku, Vercel, and traditional PaaS providers are built on proprietary architectures that lock you in.

Vendor Lock-In

Proprietary APIs and state management tie you to one provider forever

No Self-Healing

Manual intervention required when things break, no automatic reconciliation

Proprietary State

Your application state is locked in their database, not yours

Manual Drift Detection

You have to notice and fix configuration drift yourself

Feature	Heroku	Vercel	Render	Anakin
State Storage	Proprietary	Proprietary	PostgreSQL	K8s CRDs
Self-Healing	✗	✗	✗	✓
GitOps Native	✗	✗	✗	✓
Self-Host	✗	✗	✗	✓
Open Source	✗	✗	✗	✓
Plugin System	✗	✗	✗	✓

The Anakin Difference

Five key innovations that make Anakin fundamentally different from traditional PaaS platforms.

Plugin-First

Every component is a swappable plugin. Change your GitOps provider, metrics system, or log aggregator via configuration—no code changes required.

                        plugins:
  gitops:
    provider: flux # or argocd
  metrics:
    provider: prometheus
                    

Kubernetes-Native

Custom Resource Definitions (CRDs) are your source of truth. All state lives in Kubernetes, not a proprietary database.

                        apiVersion: anakin.dev/v1alpha1
kind: Project
spec:
  gitURL: github.com/user/app
  framework: nodejs
                    

CNCF-First

Built entirely on proven CNCF projects: ArgoCD for GitOps, Prometheus for metrics, Loki for logs, and Cloud Native Buildpacks for builds.

No proprietary tech. Just standards.

Self-Healing

Reconciliation controllers continuously watch your infrastructure and automatically fix drift. Pod crashed? Controller recreates it. Config changed? Auto-synced.

Typical reconciliation: 30 seconds

No Vendor Lock-In

Runs on any Kubernetes cluster—EKS, GKE, AKS, on-prem, or even K3s on a Raspberry Pi. You own the state, you own the deployment.

Your infrastructure, your rules.

Architecture Deep Dive

See exactly how data flows through Anakin—from HTTP request to deployed application.

Key Insight: Kubernetes CRDs are the source of truth. Everything else synchronizes from them.

How It Works: Step by Step

Follow a deployment from start to finish—see the actual code and commands.

Create Project

Define your application as a Kubernetes Custom Resource. This becomes the declarative source of truth.

                        # Create via kubectl or API
curl -X POST http://api.anakin.dev/projects \
  -d '{
  "name": "my-nodejs-app",
  "git_url": "github.com/user/app",
  "framework": "nodejs",
  "resources": {
    "cpu": "1",
    "memory": "1Gi"
  }
}'
                    

Controller Watches

The Project Controller detects the new CRD and begins reconciliation—setting up monitoring and preparing for deployment.

                        // Go reconciliation loop
func Reconcile(ctx, req) {
  project := &Project{}
  r.Get(ctx, req, project)

  // Create Prometheus monitor
  r.metrics.CreateMonitor(ctx, project)

  // Create Loki log stream
  r.logs.CreateStream(ctx, project)

  // Requeue after 30s
  return ctrl.Result{RequeueAfter: 30s}
}
                    

Build with Cloud Native Buildpacks

The build plugin detects your framework and automatically builds a production-ready container image.

                        # Buildpacks auto-detects Node.js
pack build my-app:abc123 \
  --builder paketobuildpacks/builder:base \
  --path ./app

✓ Node.js detected
✓ Installing dependencies
✓ Building production bundle
✓ Image built: registry/my-app:abc123
                    

Deploy with ArgoCD

The GitOps plugin creates an ArgoCD Application that continuously syncs your git repository to the cluster.

                        apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-nodejs-app
spec:
  source:
    repoURL: github.com/user/app
    targetRevision: main
  syncPolicy:
    automated:
      prune: true
      selfHeal: true # Auto-fix drift!
                    

Observe Everything

Prometheus collects metrics and Loki aggregates logs. Query them via the API or dashboard.

                        # Query metrics (PromQL)
GET /api/v1/projects/my-app/metrics

# Query logs (LogQL)
GET /api/v1/projects/my-app/logs?since=1h

# Example response:
{
  "cpu": 45.2,           // % usage
  "memory": 512.5,       // MB
  "requests": 125.3,     // req/sec
  "error_rate": 0.15     // %
}
                    

Plugin System: Zero Code Changes

Swap entire subsystems via configuration. Click to change plugins and see the magic.

Interactive Plugin Configuration

GitOps Provider

ArgoCD ✓

Flux

Metrics Provider

Prometheus ✓

VictoriaMetrics

Logs Provider

Loki ✓

Elasticsearch

Build Provider

Cloud Native Buildpacks ✓

Kaniko

Configuration updated! No code changes required.

                    # config/platform.yaml
plugins:
  gitops:
    provider: argocd
  metrics:
    provider: prometheus
  logs:
    provider: loki
  builds:
    provider: buildpacks
                

Self-Healing in Action

Watch Kubernetes reconciliation controllers automatically detect and fix problems.

Your Application Pods

Desired state: 3 healthy pods

Pod 1

Pod 2

Pod 3

Healthy Pods

Reconciliation Time (s)

Recoveries

How it works: The controller watches the CRD (desired state: 3 pods) and continuously reconciles with actual state. When a pod crashes, the controller detects the drift within 30 seconds and automatically recreates it. No manual intervention required.

Why Kubernetes-Native?

Understanding the fundamental architectural decision that makes Anakin different.

Traditional PaaS (PostgreSQL-First)

State lives in proprietary database
No reconciliation loops
Manual drift detection
No GitOps native support
Vendor lock-in
You don't own the state

Anakin (Kubernetes-Native)

State lives in K8s CRDs (your cluster)
Automatic reconciliation every 30s
Self-healing by design
GitOps: commit CRDs to git
Portable: runs on any K8s
You own everything

The Reconciliation Loop

Controllers continuously reconcile desired state (CRDs) with actual state (infrastructure)

                    // This runs every 30 seconds, forever
func Reconcile(ctx context.Context, req Request) {
  // 1. Get desired state from CRD
  project := &Project{}
  k8sClient.Get(ctx, req, project)

  // 2. Get actual state from infrastructure
  status := gitops.GetStatus(ctx, project.ID)

  // 3. Reconcile differences
  if !status.Healthy {
    gitops.Deploy(ctx, project) // Auto-fix!
  }

  // 4. Requeue
  return ctrl.Result{RequeueAfter: 30 * time.Second}
}
                

Open Core Business Model

Inspired by GitLab: 100% open source core, optional managed service.

Core Platform

Apache 2.0 License

100% open source. Self-host anywhere. Full control.

All core features
Plugin system
K8s controllers
API & Dashboard

Managed Service

Hosted Anakin

We run it for you. Pay for convenience and premium features.

Multi-region
Managed upgrades
24/7 support
SLA guarantees

Plugin Ecosystem

Mix of Free & Premium

Community plugins are free. Premium plugins add advanced features.

Free CNCF plugins
Enterprise SAML
Advanced RBAC
Compliance plugins

You own the code. You own the data. You own the infrastructure.

Built on Proven Standards

Every component is a battle-tested CNCF project. No proprietary magic.

ArgoCD

GitOps continuous delivery for Kubernetes

Prometheus

Metrics collection and alerting

Loki

Log aggregation like Prometheus for logs

Buildpacks

Cloud Native Buildpacks for container builds

Kubernetes

Industry standard container orchestration

Go

High-performance backend language

PostgreSQL

Reliable relational database

SvelteKit

Modern fast web framework

Transparent Pricing

Start free. Scale when you need. No hidden costs, ever.

Self-Hosted

FREE

Always

100% of the platform. Run on any Kubernetes cluster.

Full platform access
All core plugins
Run on any cloud
Community support
GitHub & Discord

Get Started

Developer

$29

per month

Managed control plane. Zero ops. Just deploy.

1 user, 5 projects
Managed infrastructure
Automatic updates
Single region
Email support (48h SLA)

Join Waitlist

Calculate Your Savings

See how much you'll save by switching from Heroku to Anakin

Number of Applications

apps

Average Heroku Dyno Type

Heroku Cost

$500

per month

Anakin Cost

$149

per month

70% Savings

You Save

$351

per month

$4,212/year

* Estimates based on standard Heroku pricing. Anakin costs include managed Team tier + infrastructure. Self-hosted is even cheaper (infrastructure costs only).

Get Started Today

Self-host in minutes or join the waitlist for our managed service.

Self-Host (Open Source)

Run Anakin on your own infrastructure in under 5 minutes.

                        # Clone the repo
git clone github.com/yourusername/anakin
cd anakin

# Start everything with Docker Compose
make docker-up

# Apply CRDs to your cluster
kubectl apply -f config/crds/

# Start the API
make run-api

✓ API running on http://localhost:8080
                    

View on GitHub

Managed Service

Let us handle infrastructure, updates, and scaling. Focus on building.

Multi-region deployment
Automatic updates
24/7 support
99.9% uptime SLA
Built-in monitoring
Enterprise features

Currently in private beta. Launching Q2 2026.

Questions? Join our community on Discord or GitHub Discussions

Run your PaaS on any cloud.No vendor lock-in.

Open Source. Production Ready.

Join the Community

Why existing PaaS platforms fail

Vendor Lock-In

No Self-Healing

Proprietary State

Manual Drift Detection

The Anakin Difference

Plugin-First

Kubernetes-Native

CNCF-First

Self-Healing

No Vendor Lock-In

Architecture Deep Dive

How It Works: Step by Step

Create Project

Controller Watches

Build with Cloud Native Buildpacks

Deploy with ArgoCD

Observe Everything

Plugin System: Zero Code Changes

Interactive Plugin Configuration

GitOps Provider

Metrics Provider

Logs Provider

Build Provider

Self-Healing in Action

Your Application Pods

Why Kubernetes-Native?

Traditional PaaS (PostgreSQL-First)

Anakin (Kubernetes-Native)

The Reconciliation Loop

Open Core Business Model

Core Platform

Managed Service

Plugin Ecosystem

Built on Proven Standards

ArgoCD

Prometheus

Loki

Buildpacks

Kubernetes

Go

PostgreSQL

SvelteKit

Transparent Pricing

Calculate Your Savings

Get Started Today

Self-Host (Open Source)

Managed Service

Run your PaaS on any cloud.
No vendor lock-in.