Dev locally,
run on Kubernetes

The developer runtime for Kubernetes apps. Hot-swap your code into a running pod, spin up HTTPS previews, and switch an environment between versions like you switch git branches — all from one window.

Get CodePier See what it does

Personal/CodePier/v0.0.1/developmentDEVShip

mini k3s

Assistant

LP

Piles

db-migrate

seed-data

api-gatewayproduction

auth-serviceproduction

postgresproduction

CLI

v2.0.29

/

Deployment

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-gateway
  namespace: production
  labels:
    app: api-gateway
    team: platform
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-gateway
  template:
    metadata:
      labels:
        app: api-gateway
    spec:
      containers:
      - name: api-gateway
        image: ghcr.io/codepier/api-gateway:v2.4.1
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        env:
        - name: NODE_ENV
          value: "production"
        - name: PORT
          value: "8080"

Config Maps

Key	Default	Cloud
DATABASE_HOST	localhost	db.codepier.io
DATABASE_PORT	5432	—
REDIS_URL	redis://localhost:6379	redis://redis.prod:6379
LOG_LEVEL	info	warn
API_TIMEOUT	30000	—
Add key

Everything your Kubernetes team uses, in one app

Manifests, environments, port forwards, hot-swaps, releases. The day-to-day work of running on Kubernetes, on a desk where you can actually see it.

Port Forwards

Pin any cluster Service to your machine and reach it at a friendly hostname like api.local. Because the proxy publishes over mDNS, the same URL works from your laptop, your phone, or any device on the network.

Hot-swap into a Pod

Run codepier up and your laptop becomes the pod. Your files sync live, ports forward automatically, and the original deployment is restored when you exit.

Pod Logs

Tail any pod, any container, with filters that actually work. Open multiple streams side by side without juggling a stack of terminals.

Matched Builds

CodePier watches your CI registry and ties every new image back to the workload it belongs to. One click swaps a running deployment to the latest tag.

Team Workspaces

Projects, services, and environment configs live in a shared workspace. Everyone on your team works from the same manifests and the same audit log.

Built-in K8s Assistant

A built-in AI assistant that reads your manifests, your environments, and your live cluster state before it answers. Suggestions you can apply, not YAML it pulled out of thin air.

Cost Visibility

OpenCost wired in. Drill from a cluster down to a single workload and see what it costs you per hour.

Secrets, Done Right

Encrypted secrets sit alongside your project and sync into the cluster through External Secrets Operator. No second secrets product to set up or pay for.

Git Sync

Connect a GitHub or GitLab repo and CodePier keeps your manifests in sync as you edit them. Your repo stays the source of truth, no Argo or Flux ceremony required.

Cluster Import

Point CodePier at a cluster you already run. It scans your Deployments, StatefulSets, DaemonSets, Services, Ingresses, ConfigMaps, Secrets, and PVCs, then imports them grouped by service. Nothing restarts.

Helm, Without the CLI

Browse charts, set values per environment, and install to any cluster from inside CodePier. The helm binary stays in the box.

Drift Detection & Audit Log

Every manifest carries a sync status. The moment cluster state drifts from what you wrote, you see it on the resource, and every change lands in the audit log.

Versioned Releases

Snapshot your manifests and environment overrides as a tagged release. Pin a specific build per environment and promote it forward when you're ready.

Environment Overlays

Environments share your base manifests, then branch where it matters. Each one runs in its own namespace with its own config maps and secrets — ideal for separating on-prem and cloud deployments that share most of their manifests but each need their own extras.

Coming Soon

Preview Environments

An isolated namespace for every pull request, deployed to your cluster, with a shareable URL. Reviewers see the real thing instead of a screenshot.

Coming Soon

Multi-Version Environments

Run several versions of your app side-by-side in the same cluster. Alice tests her feature branch, Bob validates a rollback, Charlie checks the release candidate — all at once, all reachable.

Coming Soon

Edge Preview URLs

CodePier's edge owns the DNS and TLS for preview hostnames. An outbound tunnel routes traffic to your cluster — no wildcard certs, no ingress setup, no firewall changes. Share a link, it just loads.

Coming Soon

Stable Preview Auth

Previews share one stable auth domain, so OAuth callbacks don't need to be registered for every new branch URL. Sign in once, bounce into any preview.

Terminal — codepier-cli

CLI

One command and
you're inside the pod

Run codepier up and CodePier hot-swaps your laptop into a running deployment. Your files sync live, the Service's ports come back to you, and the original deployment restores itself when you exit.

Hot-swap any deployment — Pick a namespace and a workload, and you're in

Live file sync — The remote pod stays in sync with your local edits

Port forwards come along — The Service's ports show up on your machine automatically

Clean exit — Quit the session and the original deployment is restored

Core Feature

The cluster,
on your desk

Point CodePier at a kubeconfig and the cluster shows up like a local app. Pin services to ports you already use, route ingresses through a .local hostname, and tail any pod from the sidebar.

Uses your kubeconfig — Any cluster you can already reach with kubectl

Port Forwards — Pin a Service to a local port and leave it there

Ingress Proxy — Cluster ingresses publish as .local hostnames with auto TLS, reachable from every device on your network — including your phone

Pod logs — Tail any pod or container, with multiple streams open at once

Personal/CodePier/v0.0.1/developmentDEVShip

mini k3s

Assistant

LP

api-gatewayproduction

auth-serviceproduction

postgresproduction

redisproduction

api-gateway-7d4f8b6c9-x2k8m

main

Waiting for logs...

Onboarding

Bring your existing
cluster with you

CodePier scans the cluster you already run. Pick the Deployments, StatefulSets, and DaemonSets you want, and it pulls in their Services, Ingresses, ConfigMaps, Secrets, and PVCs, grouped by service. Nothing on the cluster moves.

Zero-downtime import — Your workloads keep running. Nothing is redeployed or restarted

Grouped by namespace — Every workload in the cluster, sorted into the namespace it lives in

Pick your resources — Toggle individual Services, Ingresses, Volumes, and Secrets in or out

Workable on day one — Logs, status, and manifests are all there the second you import

Personal/CodePier/v0.0.1/developmentDEVShip

mini k3s

Assistant

LP

Select workloads to import

Each workload is imported with its related resources. Uncheck anything you don't want.

4 selected

Overlays

Share the base,
swap the surroundings

Overlays pick which services ship together and give each deployment target its own namespace, config maps, and secrets. Share your API and web services across prod and on-prem, then layer on whatever each target needs on its own.

Share the base — Reuse the same manifests across targets instead of duplicating them

Scope config per target — Each target gets its own namespace, config maps, and secrets

Separate prod from on-prem — Share a common set of services and add the ones each target needs on its own

Make your own — Cloud, on-prem, QA, canary, load-test. Whatever targets you need

Personal/CodePier/v0.0.1/developmentDEVShip

mini k3s

Assistant

LP

Overlays

2 overlays

Group piles into deployment targets with per-overlay namespaces.

Cloud

3 piles9T

Primary cloud deployment — AWS EKS with managed load balancers

productionstaging

Pile Namespaces

api-gateway

codepier-cloud

auth-service

codepier-cloud

worker-pool

codepier-cloud

Labels2

app.kubernetes.io/managed-by=codepier

team=platform

Annotations1

codepier.io/project-version=v0.0.1

Images2

codepier/apighcr.io/codepier/api-gateway:v2.4.1

codepier/authghcr.io/codepier/auth-service:v2.4.1

Replicas3

api-gateway3

auth-service3

worker-pool5

Name Transformers

prefix:cloud-

Premise

2 piles5T

Personal/CodePier/v0.0.1/developmentDEVShip

mini k3s

Assistant

LP

Active Previews

feat/auth-v2#142luke12m ago

ready4/4 podsauth-v2.preview.codepier.io

fix/rate-limiter#138sarah1h ago

ready4/4 podsrate-limiter.preview.codepier.io

feat/billing-ui#145alex3m ago

deploying...2/4 podsbilling-ui.preview.codepier.io

$ Creating preview for feat/billing-ui...

✓ Namespace billing-ui-preview created

✓ Manifests applied (4 resources)

⟳ Waiting for pods: 2/4 ready

Share: billing-ui.preview.codepier.io

Coming Soon

A preview for
every pull request

Open a PR and CodePier spins up an isolated namespace on your cluster, running your full stack. You get a URL to share with the rest of the team so they can poke at the real thing instead of reading a screenshot.

Runs on your cluster — Previews live in your infrastructure, not ours

Full stack, isolated — Each PR gets its own namespace with every service it needs

Shareable URLs — Anyone on the team can click in. No local setup required

Auto-cleanup — The environment tears itself down when the PR merges or closes

How it works

From a fresh kubeconfig to a production deploy, in one app you and your team already know how to use.

01

Pull in your cluster

Import the workloads you already run or start a new service from scratch. CodePier scans Deployments, StatefulSets, DaemonSets, and their dependencies and groups them the way you'd group them yourself.

02

Work against the real thing

Pin Services to local ports, route ingresses through .local hostnames with TLS, tail pod logs from the sidebar, or run codepier up to hot-swap your laptop into any pod.

03

Edit, diff, and ship

Open the Manifest Editor, layer on per-environment overrides, and hit Ship It. Drift shows up the moment something diverges from what you wrote.

04

Snapshot, promote, repeat

Tag a release when you're happy with a build. Pin it to staging, push it forward to production, and keep your whole team working out of the same shared workspace.