Eject

Ejectability is what makes Lucity different from every other PaaS. When you eject, you get a fully self-contained package of standard infrastructure-as-code. No Lucity dependencies. No proprietary formats. No "please contact support to export your configuration." Just Helm charts, ArgoCD configs, and a README that tells you exactly what to do next.

This isn't a bolt-on feature or an afterthought. Ejectability is the design constraint that shapes every decision in the platform.

See what you get

Run eject and you receive a complete, portable infrastructure package:

ejected-project/
├── base/                          # Shared Helm values
│   ├── Chart.yaml
│   └── values.yaml
├── environments/                  # Per-environment overrides
│   ├── development/
│   │   └── values.yaml
│   ├── staging/
│   │   └── values.yaml
│   └── production/
│       └── values.yaml
├── chart/                         # Complete lucity-app chart
│   ├── Chart.yaml
│   ├── templates/
│   │   ├── deployment.yaml
│   │   ├── service.yaml
│   │   ├── httproute.yaml
│   │   ├── configmap.yaml
│   │   └── ...
│   └── values.yaml
├── argocd/                        # ArgoCD Application manifests
│   └── applications/
│       ├── development.yaml
│       ├── staging.yaml
│       └── production.yaml
└── README.md                      # Setup guide: prerequisites, commands, modifications

Everything your application needs to run on Kubernetes, without Lucity in the picture. The chart directory contains the full lucity-app Helm chart, not a reference to it, but the actual templates. The ArgoCD manifests are ready to apply. The values files are your values, exactly as you configured them.

Use the ejected output

Point your own ArgoCD at the ejected repository and you're running independently:

# Apply the ArgoCD Applications
kubectl apply -f argocd/applications/

# Or use Helm directly
helm install myapp-production ./chart \
  -f base/values.yaml \
  -f environments/production/values.yaml \
  -n myapp-production

The README walks you through everything: prerequisites (Kubernetes cluster, ArgoCD, Gateway API CRDs), step-by-step setup commands, and how to modify values when your needs change. It's written for the engineer who takes over after you eject, whether that's you in six months or a new team member.

Understand why ejectability matters

Other platforms give you a nice dashboard but hold your infrastructure hostage. Your configuration lives in their systems, in their formats, behind their APIs. It works great until it doesn't, and then you're stuck.

When you outgrow Railway, you start from scratch. When you outgrow Heroku, you hire a platform team to rebuild everything. When you outgrow Render, you spend weeks reverse-engineering what was actually running.

When you outgrow Lucity, you take everything with you. The platform is a convenience layer, not a dependency. You chose Lucity because it made deployment easy. You leave Lucity with everything you need to keep deploying without it.

That's not a failure case we reluctantly planned for. It's the whole point.

Apply the ejectability test

Every Lucity feature is designed with ejection in mind. Before a feature ships, the team asks one question:

"If a user runs lucity eject right now, does this feature survive?"

If a feature can't be represented as standard Kubernetes resources, Helm values, and ArgoCD configurations after ejection, it doesn't belong in the platform. Full stop.

This constraint is demanding. It means we can't take shortcuts with proprietary CRDs. We can't build features that only work inside our runtime. We can't create abstractions that collapse without our control plane. And that's exactly the discipline that keeps the platform honest.

Trust standard tools all the way down

The ejected output doesn't use anything exotic:

• Helm for packaging and templating.
• ArgoCD for GitOps delivery.
• Gateway API for networking and ingress.
• CloudNativePG for PostgreSQL.
• Kubernetes for everything else.

No custom operators that need Lucity's control plane. No proprietary CRDs that only our dashboard understands. No vendor-specific annotations that break without our webhook. Standard kubectl works for every resource in the ejected output.

You can modify the Helm templates. You can swap ArgoCD for Flux. You can replace Gateway API with an Ingress controller. The ejected output is yours. Do whatever you want with it.

Most platforms say "trust us." We say "here are your keys."