MeerkatTake the app you
built this weekend
straight to production.
Meerkat takes a git repository, like a GitHub repo, and gives it a container build, a reviewed release pipeline, gated secrets, scanned and hardened images, and continuous watching. Nothing to stand up. Nothing to babysit. Nothing locked in.
- Your code stays in your own repo
- Secrets never touch the repo
- One command from repo to release
$ blankcut promote --repo github.com/northwind/api✓ scaffolding Dockerfile, CI, key declaration✓ repo scan no risky build patterns✓ image build api:2.14.2@sha256:9f2c1a✓ image scan no critical CVEs✓ secrets 6 keys matched, none in the repo✓ release PR #204 opened for review→ waiting on your approval to promotenorthwind-api · digest-pinned rollout
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. That list is the whole job now, and it is the job we do.
Without a platform
- Weeks of infra work before the first user sees it
- Secrets living in a .env on one laptop
- Deploys nobody can explain or reverse
- "It works on my machine" as a release process
- An agent that invents a new way to deploy every session
- A cloud bill that arrives four times larger than the app
With Meerkat
- One command from repo to a reviewed production release
- Encrypted store and keys allowlisted
- Every deploy is a diff someone approved
- Repo and image both scanned before anything runs
- A CLAUDE.md that holds your agent to the architecture
- Resources sized for the app, so the bill is the app
How it works
Four steps, then it runs itself.
You install one app on one repository. Everything after that happens as pull requests in your own repo, which means you can read, review and revert all of it.
Connect a repository
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.
Merge the scaffolding PR
We open a pull request adding what's missing: a hardened multi-stage Dockerfile, the build workflow, a deploy manifest, and a declaration of the keys your app may read.
Approve the release
Each promotion becomes one reviewable change to the deployment config. Approve it and the scanned image rolls out with probes, right-sized resources and a rollback path.
Watch it live
App health, pod restarts, log tail, alerts and spend, all in one place and scoped to your apps.
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 next teammate reads.
Your agent ships with the same CLI you do
It runs blankcut, not a cloud API, so its work lands on the reviewed path.
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 repo declares which keys are permitted, and a key it never declared is not available even if someone sets one.
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 constructionScanned before the build, and after it
Before: your repo is checked for committed credentials, risky install steps and untrusted base images, on every build. After: the image is scanned for known CVEs in the registry. The CLI runs the same repo checks locally, so a finding reaches you before a push does.
Source, build inputs, and the image itselfHardened images by default
The Dockerfile we scaffold is the safe one: multi-stage, slim runtime, no build toolchain in the final layer, running as a non-root user. Images are digest-pinned, so what you reviewed is what runs and no 'latest' tag decides your production version.
Non-root, slim, digest-pinnedTenant 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 continuouslyTwo ways to work
Wizard, terminal, or your coding agent.
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, and your agent can drive the same CLI you do.
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, or my agent does
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. Claude Code runs the same commands, and blankcut validate tells it what would fail before it opens a pull request.
blankcut validateblankcut 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. Every 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
TodayEvery release is hand-driven, so shipping only happens when you are at the keyboard and remember the steps.
With usBuild, promote and roll back are automated and reviewable. The pipeline is the process, not a person.
You need production-grade security, early
TodayReal users are about to type real data into something you wired up over a weekend, and hardening it is still a list of things you meant to get to.
With usEncrypted secret store, key allowlisting, CVE-scanned and hardened non-root images, tenant isolation and a git audit trail, all on by default from 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 nobody to hand the infrastructure to
TodayThere is no ops person, and learning enough to feel safe about production is a project of its own on top of the app.
With usThe platform team is us. Cluster health, patching and alerting 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 own account.
Rough Cut
New featureStaging, in miniature.
A Rough Cut is a small environment of its own: the same pipeline, the same scanning, its own namespace and resources, sized for something you are still figuring out. One per idea, rather than one big staging tier per company, at a flat $9.99 per month each.
Walled off from production
Its own namespace and its own resources. Whatever you break in here cannot reach the app your users are on.
Ships without the ceremony
Rough Cut releases merge on the automated scope guard instead of waiting for an approval, so the loop stays as fast as the idea.
A flat $9.99 a month
Per environment, not per hour. No compute metering and no overage to reason about, so a prototype that idles all week costs the same as one you hammer. Your plan caps how many you can run at once: 1 on Growth, 3 on Scale.
Pricing
A base fee, then what you actually use.
Compute is metered hourly against an included quota. Databases, domains and storage are per unit, and every invoice breaks down where it went. No seat maths and no surprise egress line.
Your first app in production, on real infrastructure.
556 CPU-hr
included, then $0.000050/CPU-sec
- Console and CLI, same capabilities in both
- Reviewed release pipeline with one-action rollback
- Encrypted secrets, CVE-scanned and hardened images
- Alerts in the portal and by email
A few apps in production, plus room to prototype.
1,667 CPU-hr
included, then $0.000045/CPU-sec
- Everything in Starter
- Up to 1 Rough Cut environment, $9.99 each
- 3x the included compute, at a lower overage rate
- Business-hours support window
Production workloads, and billing your own clients.
4,167 CPU-hr
included, then $0.000040/CPU-sec
- Everything in Growth
- Up to 3 Rough Cut environments, $9.99 each
- Largest included compute, lowest overage rate
- Stripe Connect billing for your own customers
High-capacity or regulated workloads, priced per engagement.
Per-customer metered rates.
- Negotiated per-deployment pricing
- Per-customer metered rates
- Rough Cut allowance set by your contract
- Direct line to the platform team
On every plan: managed Postgres databases, managed domains, object storage and support hours an engineer logs are metered per unit, at the rates shown in your console before you add anything. Rough Cut environments are a flat $9.99 each per month. Compute overage past the included quota is billed at period end. Cancel any time, the repo and image are already yours.
Production infrastructure your AI-built apps can depend on.
Connect a repository and watch the scaffolding pull request open. No card, no sales call, and nothing lands on your default branch until you merge it.