Not just an app — an entire scalable tech company from a single prompt.
You're on the list. We'll be in touch with a cohort slot.
Free while it's early · pricing locked for the cohort · {{ seats }} slots left
Why Chinook is different
With generated code, the demo is where the good news ends — every upgrade, guarantee and integration becomes your homework. Chinook keeps owning those, so the next change costs less than the last one.
A generated codebase is frozen the day it's generated — improvements never reach it. A Chinook app is built on a platform that upgrades continuously, so every fix and every new capability reaches your app automatically.
Every change is tried on its own live copy first, reviewed before it ships, and reversible with one click — so speed never comes at the price of an outage.
Payments, SSO, billing, invoices, uploads, background jobs, audit logs, app-store submissions — none of it is your product, and all of it usually eats the first year. Here it's switched on, not built.
Built by the YC founders behind Bolster — the platform residential contractors run their estimating, payments and field work on.
Coding, cloud, payments, support, security and collaborative AI are one system reading one document — not seven products duct-taped at the seams. Runs on web, iOS, Android and desktop, as simple as a single slide deck or as big as an international multi-million-user marketplace.
platforms from one build
capabilities built in
DevOps hires required
Real git, real TypeScript, in the browser
A shared agent on every branch
AWS underneath, hidden — no DevOps required
Collected through the app, automatically
Bugs tracked and fixed automatically — a report opens a fix/* branch
Isolation, audit and data rights, automatic
A document can't rot; the fleet upgrades
The demo is the app. The app is the business.
How it works
Your whole app is described in one living blueprint. You ask for a change in plain language and it lands in a safe sandbox — a live copy of the app with its own data, where anyone on the team can experiment without touching what customers see. Review what will happen before it happens, then press one button to ship — code, tests, docs and deployment all follow automatically.
Plain language, or start from a working template. No setup, nothing to install.
All at once, in one place — a live copy with its own data that anyone can tweak. Customers never see it.
See exactly what will happen before it happens — anything risky is flagged for you.
One click to web, iOS, Android and desktop — migrations, tests and deployment handled.
Promotion is a button, not a runbook. Chinook derives the database migrations, generates the tests, structures the review, and runs your entire service stack — automatically. And because every version carries a full snapshot, rollback is one click too: it appends, never rewinds, so the history never lies.
A code-generating builder's output scales with the size of your application. Chinook's scales with the size of the change in intent. That gap does not close as your product grows — it widens.
Multiplayer by default
Every app lives in one git repository on the platform, a worktree per branch — which means your whole company can build the product, not just the two people who can code. Ideas stop dying in a backlog: the person who understands the customer makes the change, tries it safely on real-feeling data, and nothing reaches customers without review. Faster shipping, fewer translation losses between "what sales promised" and "what got built", and an undo that never lies. Sharing is as easy as Google Docs: send a link, they're in the running app.
Design, code and test in the same console simultaneously — each stream of work on its own branch, so nobody blocks anybody. The branch conversation is shared: what one collaborator asked the AI, everyone can read.
A non-coder describes a new feature; it automatically goes into a new feature/* branch and surfaces a live preview with its own ephemeral database — so they, or anyone on your team, can tweak and test instantly. Production never saw it.
master mirrors production, and every change flows through the same gate — validate, diff, review, promote — whether it came from your CTO or your office manager. The demo is the app; the app is the business.
Invite someone the way you'd share a Google Doc — a link and a role, and they're in the running app. No Docker, no npm, no downloads, no "works on my machine", no proprietary copy on a contractor's laptop. A browser is the whole toolchain.
A week on Chinook
Because usage, support, code and deployment read the same document, a signal anywhere becomes a reviewed, shippable change — without a ticket queue in between. That's retention saved the week the problem appears instead of the quarter after, and the diagnose-reproduce-patch-test grind automated away: your team spends its hours deciding what ships, not producing it.
Retention signal
Retention tracking spots a confusion checkpoint — 40% of new users abandon the same form field.
Usage metering flags the drop-off checkpoint
The AI codes a suggested fix on fix/onboarding-step and notifies you
You open the branch, see the change live, make a few tweaks
Ship. Migration derived, tests green, rollback one click away
Support signal
The in-app support agent takes the report — no screenshots over email, no triage meeting.
The report lands in bug tracking with the session context attached
The agent reviews the footage and data, then writes a fix on fix/*
A regression test pins the bug so it can never come back silently
It ships — or waits for your approval; your policy, your call
Field signal
The same ask keeps coming up in sales meetings. Nobody writes a spec document about it.
Your salesperson vibe-codes the feature between demos, on a feature/* branch
Head of customer success clicks through it in the live demo that afternoon
Head of product reviews the diff — security first, nothing destructive
Launched by end of day. Three people, zero engineers blocked
Revenue signal
Power users keep asking for bulk export. Make it a plan, not a promise.
Describe the tier; it becomes plan and entitlement fields in the spec
Features gate themselves — one entitlement check, no scattered conditionals
Subscriptions and payments collect through the app, automatically
Usage metering tells you if the tier earns its keep
The platform
Every one of these is a field in the document with a screen in the console. You enable it and configure it; you do not integrate it.
The months of sign-in plumbing that delay every launch — and the breach a homegrown version invites — already done. Close enterprise deals the day they ask for SSO.
Revenue from day one, not month six. Let your users take payments — and their users too. Flexible, affordable payments, collected through the app automatically.
Ship AI features without an AI bill you can't predict: any provider, one call, per-tenant spend caps enforced for you. No surprise invoice, no key management.
Photos, documents and uploads just work — fast, direct from the browser, and one customer can never see another's files. Zero storage infrastructure to build or babysit.
Email, push and in-app inbox from one declaration — the difference between users who come back and users who forget you, without wiring three delivery services.
Reports, imports and scheduled work run reliably in the background — no queue infrastructure to stand up, and a job can never act as the wrong customer.
Plans, subscriptions and feature gating as spec data, not conditionals — gate a feature with one call, and billing follows the plan automatically.
See what customers actually use — which features earn their keep, where users stall, and what to bill for. Signals the AI can act on.
Pass the security questionnaire instead of losing the quarter to it: audit trail, export and erasure are already on, so GDPR requests and enterprise diligence are answers, not projects.
Become a platform, not just a product: flip one switch and partners can integrate against a documented API that stays in sync with your app — no docs to maintain by hand.
Your customers' AI assistants can use your app the moment they ask — same permissions, no side door. Be the tool the agent reaches for, years before competitors retrofit it.
Automatic translation into any language, no configuration required — the strings live in the document, so a new locale is never a refactor.
Scale-to-zero by default
Capacitor + Fastlane
Gradle from the same file
Same document, no fork
Who this is for
Build your demo — which is your app, which is your business. Design, build, test and ship without changing tabs: the thing you pitch takes payments and hits the app stores the same day, each step one click.
Port your existing code into Chinook and automate the maintenance. Bugs fixed automatically, Sally from sales builds a new internal tool, Charlie from CS creates a new feature — your entire company becomes product managers.
Build your own software — easily shareable docs, presentations, websites, utilities and full apps, plus the complex, specific tools off-the-shelf software never quite fits — with everything in one place and nobody new to hire.
Time to clickable
Ask a raw AI to build your app and you get source files — then the real work starts: a database, hosting, accounts, payments, a deploy pipeline. Ask Chinook and the same sentence produces the entire running stack — and it's public, with a URL you can share, in five minutes.
And when you fill it with examples, those are real rows written through your app's own API, flagged as samples and removable in one click. We never show you invented data and call it yours.
Contacts, deals, stages, owners
Snags, sites, sign-off
Jobs, techs, visits, parts
Resources, slots, payments
Buyers, sellers, listings, split payments & payouts
Teams, plans, gated features, recurring billing
Plans
Apps scale to zero by default, so an idea that nobody uses costs nothing to keep alive. Indicative early-access pricing — locked for the design-partner cohort.
For the idea you want clickable this afternoon.
Unlimited apps, scale-to-zero
Full kernel — isolation, RLS, audit log
Templates, branches, diffs, rollback
Web preview and web deploy
Cold starts. Community support.
For the app with customers in it.
Everything in Spawn, warm runtime
Payments, AI gateway, notifications, files
iOS, Android and desktop builds
SSO, plan gating, usage metering
Generated OpenAPI, webhooks, MCP
Cohort price locked for 24 months
For the app you already run, and the fleet around it.
Agent-driven kernel retrofit
Sabotage suite against your database
Per-entity proxy and port bindings
Bring your own Postgres or MySQL
Private cloud, SSO, DPA, audit export
Retrofit is scoped to backstopped databases only.
Yes — each app has its own git repository, with a worktree per branch, and agents write real HTML and TypeScript for components and pages. The distinction is what is code and what is schema: routing, storage, entities, caching, payments, permissions and roles are fields in the document, because those are the things that must stay upgradeable and reviewable. Bespoke screens are code, and they are yours.
It is the risk we designed hardest against, and we do not pretend otherwise. Three defences: the agent produces configuration, which you review as data in a security-first diff; the derived tenancy boundary requires a human yes before any DDL runs; and a sabotage suite generated from that spec is run adversarially against the real database. On a backstopped database a wrong-but-narrower boundary breaks visibly rather than leaking.
Less than with a generated codebase, which is a fork nobody can maintain. Your data is in a Postgres you can point at, or in your own database if you bind entities that way. Your app has a generated OpenAPI contract. And the kernel is a library, not a service you must keep calling — the isolation guarantee lives in row-level security in your database, which is language-neutral and stays behind if you leave.
Yes, and you do not need a port of the kernel to do it. The load-bearing guarantee lives in Postgres, which is language-neutral: a Python, PHP or Go app gets the full backstop by verifying the signed context and setting two session variables on its connection — a shim on the order of a hundred lines. Beyond that, the gateway can run as a service and you send filter trees over HTTP. Full language ports come last and only against a generated conformance suite, because two implementations of security logic that must agree forever is a liability, not a feature.
They are excellent at minute one. The arguments we win are the ones that decide the next three years: derived isolation instead of hand-written filters, reviewable structural edits instead of a wall of diffed code, derived migrations, branch promotion, audit and data rights in the box, store builds from the same document, and a fleet that takes upgrades. Their output scales with the size of your application; ours scales with the size of your change.
A call, a look at your app or your idea, and an honest answer about the best way in — a new build, or porting your existing app. If it's a port, we show you the results on your own code before you commit to anything. Free while it's early, price locked for two years, and direct access to the people who write the decision records.
{{ seats }} design-partner slots left. Free while it's early, price locked for two years.
You're on the list. Watch for a cohort slot.
No credit card. No sales sequence. One human reply.