MeerkatYou built it in
an afternoon.
Ship it the same day.
Meerkat takes a GitHub repo — yours, or one we create in your account — and gives it a container build, a reviewed release pipeline, gated secrets, and continuous watching. No Kubernetes to learn. No CI dashboards to babysit. No lock-in.
- Your code stays in your GitHub
- Secrets never touch the repo
- One command from repo to release
$ blankcut promote --repo github.com/northwind/api✓ scaffolding Dockerfile, CI, .env.example✓ image build ghcr.io/northwind/api:2.14.2✓ secrets 6 keys matched .env.example✓ release PR #204 opened for review→ waiting on your approval to promotenorthwind-api · staging → production
The gap
Writing the app stopped being the hard part.
Claude Code can take a feature from idea to working code in an afternoon. Then it sits on a branch while somebody figures out Dockerfiles, a registry, secrets management, ingress, TLS, probes, autoscaling, alerting and who gets paged at 3am. The bottleneck moved — most platforms still solve the old one.
Without a platform
- Weeks of infra work before the first user sees it
- Secrets in a .env pasted into Slack
- Deploys nobody can explain or reverse
- "It works on my machine" as a release process
- An AI that happily invents a fourth way to deploy
With Meerkat
- One command from repo to a reviewed production release
- Encrypted store, keys allowlisted by your own .env.example
- Every deploy is a diff someone approved
- The same pipeline on every app, every tenant
- A CLAUDE.md that holds your AI to the architecture
How it works
Four steps, then it runs itself.
You install a GitHub App. Everything after that happens as pull requests in your own repository — which means you can read, review and revert all of it.
Connect GitHub
Install the Blank Cut App on a repo you already have — or let us create a private one in your account, seeded with a runnable Next.js or Vite starter.
Your account. Your code. Always.Merge the scaffolding PR
We open a pull request adding what's missing: a multi-stage Dockerfile, the build workflow, a deploy manifest, and .env.example declaring the keys your app may read.
Nothing touches your default branch.Approve the release
Each promotion becomes one reviewable change to the deployment config. Approve it and the image rolls out through ArgoCD with probes, resource floors and a rollback path.
No kubectl. No console clicking.Watch it live
Cluster health, pod restarts, log tail, alert routing and spend — all of it in one place, scoped to your apps.
Live via SSE.For Claude Code users
Your agent writes the code.
We hold the architecture.
Every repo we scaffold ships with a CLAUDE.md describing the platform's conventions — where config lives, how secrets are declared, what the health endpoint must return, how a release is cut. Point Claude Code at the folder and it builds inside those rails instead of inventing its own deployment story every session.
Conventions written down, not tribal
The same file your agent reads is the one your new hire reads.
Agent-authored changes still get reviewed
A PR is a PR, whoever typed it.
Secrets stay out of the context window
Values live in the platform store; the repo only names the keys.
# northwind-api## DeploymentThis app runs as a container on the Blank Cutplatform. Do not add Helm charts, raw k8smanifests, or a second CI system.## ConfigEvery key the app reads MUST be declared in.env.example. That file is the allowlist —an undeclared key is unavailable at runtime.## HealthGET /health returns 200 + {"status":"ok"}once dependencies are reachable.## Releasingblankcut promote --app northwind-apiOpens a reviewed deploy change.
Security, not security theatre
The safe path is the only path.
Guardrails you have to remember aren't guardrails. Ours are load-bearing: there is no way to ship that skips them, because shipping is the pipeline.
Secrets never touch the repo
Values live in an encrypted platform store, injected at runtime. Your .env.example declares which keys are even permitted — an undeclared key simply is not available.
Rotate without a redeployEvery change is reviewed
Deploys are diffs against the deployment config, not imperative commands. Approvals, authorship and rollbacks are all in git history.
Full audit trail by constructionImages built and pinned
Multi-stage builds on a slim runtime, digest-pinned so what you reviewed is what runs. No 'latest' tags in production.
Reproducible by digestTenant isolation by default
Every customer gets their own namespaces with network policy, resource quotas and separate credentials. Cross-tenant access is not a setting you can misconfigure.
Namespace-scoped RBACWatched around the clock
Cluster and app health stream into Meerkat. Critical alerts route to the platform team; warnings batch. Thresholds are cluster defaults tenants can tighten but not loosen.
Alert rules evaluated continuouslyNo lock-in, by construction
The repo is in your GitHub from day one, and the container is a standard OCI image. If you leave, you keep a working app — nothing to extract.
Leave whenever. Take everything.Two ways to work
Wizard or terminal. Same machinery.
Nothing in the platform is UI-only or CLI-only. Pick the surface that suits you; your teammate can pick the other one on the same app.
I describe what I want
Guided flows, no terminal required
A short interview picks your path, then wizards handle GitHub, the starter repo, the database and the first deploy. Claude Code writes the app; we run it.
- Create a project in your GitHub account
- Import an existing repo
- Add a managed Postgres database
- Promote from a button, watch the rollout
I live in the terminal
One binary, scriptable end to end
Install the CLI, point it at a repo, and drive the whole pipeline from your shell — including the parts the wizard walks you through.
blankcut promote --repo <url>blankcut provision --stack nextjsblankcut secrets push --app <app>blankcut status --app <app>Who it's for
If any of these is your Tuesday, we built this for you.
You ship with Claude Code or Cursor
TodayFeatures land in hours and then queue behind infra work nobody owns. Each session your agent invents a slightly different deployment.
With usA scaffolded repo with a CLAUDE.md your agent obeys, and one command from branch to reviewed production release.
You need a pipeline that runs without you
TodaySomeone hand-holds every release. Deploys happen when that person is awake and not on holiday.
With usBuild, promote and roll back are automated and reviewable. The pipeline is the process — not a person.
You need production-grade security, early
TodayYou know the audit is coming and the honest answer to "where do secrets live?" is a pinned Slack message.
With usEncrypted secret store, key allowlisting, tenant isolation, digest-pinned images and a git audit trail — on by default, day one.
You need to get to production, fast
TodayA prototype needs to be real by Friday and there's no time to stand up a platform first.
With usConnect GitHub, merge the scaffolding PR, approve the release. That's the whole path.
You have no platform or DevOps hire
TodayYour best product engineer is a part-time reluctant SRE, and the bus factor is one.
With usThe platform team is us. Cluster health, patching and alert routing are ours; your app is yours.
You ship apps for clients
TodayEvery engagement rebuilds the same pipeline, and handover means untangling your accounts from theirs.
With usEach client is a tenant with their own namespaces, billing and portal — and their repo already lives in their GitHub.
Pricing
A base fee, then what you actually use.
Compute is metered hourly against an included quota; databases, domains and storage are per-unit. Every invoice breaks down where it went — no seat maths, no surprise egress line.
Single-deployment apps. For a prototype that needs to be real.
556 CPU-hr
included, then $0.000050/CPU-sec
- Full console access
- Reviewed release pipeline
- Encrypted secret store
- Managed Postgres available as an add-on
Multi-deployment, moderate scale. The usual starting point.
1,667 CPU-hr
included, then $0.000045/CPU-sec
- Everything in Starter
- Multiple apps and namespaces
- Alert routing
- Staging + production environments
Production-grade, multi-namespace workloads.
4,167 CPU-hr
included, then $0.000040/CPU-sec
- Everything in Growth
- Highest included compute quota
- Stripe Connect billing
- Custom retention & quotas
High-capacity or regulated workloads, priced per engagement.
Per-customer metered rates.
- Negotiated per-deployment pricing
- Per-customer metered rates
- Bespoke agreements
- Direct line to the platform team
All plans: metered overage past the included quota, billed at period end. Cancel any time — the repo and image are already yours.
Questions
The ones people actually ask.
Where does my code live?
In your GitHub account, from the first minute. We connect through a GitHub App you install and can revoke; we never host your repository. If you stop paying us tomorrow you still have a working, buildable app.
Do I need to know Kubernetes?
No — and you shouldn't have to. Underneath it's Kubernetes with ArgoCD, and you can see all of it in the console if you want to. But the surface you work with is a repo, a pull request and a promote button.
What if my repo has no Dockerfile?
Then the scaffolding PR writes one — multi-stage, slim runtime — along with the build workflow, deploy manifest and .env.example. You review it like any other pull request.
How do secrets work, exactly?
Values are stored encrypted on the platform and injected at runtime. Which keys are permitted is declared by .env.example in your repo — that file is the allowlist, so an undeclared key is unavailable even if someone sets it. Nothing sensitive is ever committed.
Can my AI agent break production?
It can open pull requests, which is exactly as much power as any teammate has. Promotion needs an approval, releases are diffs, and rollback is one action. The CLAUDE.md in the repo keeps its suggestions inside the platform's architecture in the first place.
What happens if I outgrow you?
You take the repo, the image and the manifests — all standard, all already in your possession. We'd rather be left cleanly than hold anyone hostage.
Ship what you built this afternoon.
Connect a repo and watch the scaffolding pull request open. No card, no sales call, and nothing lands on your default branch until you merge it.