---
name: waitlist
description: "Set up the Waitlist company template on naïve for the person you work for: ask its setup questions, install it with the naive CLI or the API, then hand them the approvals."
url: https://usenaive.ai/companies/waitlist
blueprint: starter
template: waitlist
---

# Waitlist on naïve

A person asked you, their coding agent, to set up the Waitlist company for them on naïve. Follow this file top to bottom. A page that collects emails for what you are launching. Each new sign-up gets its confirm link within the hour, and you say when to email everyone. Every announcement waits for your approval.

- Page: https://usenaive.ai/companies/waitlist
- Listing (the source of truth, no key needed): `GET https://api.vetta.sh/v1/blueprints/artifacts/starter/waitlist`, release 0.2.0. Where it and this file disagree, the listing wins.

## What this template runs

| Part | Name | What it does |
| --- | --- | --- |
| Agent | `launcher` (required) | Launch. Writes your waitlist page, tells you who signed up, and emails everyone when you launch. |
| Agent | `confirmer` (required) | Confirm links. Sends each new sign-up the link that puts them on the list, within the hour. |
| App | `waitlist` | fullstack. Your waitlist page and its sign-ups. |
| Persona | `owner` | The owner: the persona the agent emails as. |

| Timer | When | Does |
| --- | --- | --- |
| `confirmer` | `0 * * * *` | Confirm links to new sign-ups |

- Deploys: Your waitlist page
- Sign-ups: Confirmed by email
- Agents: Launch and confirm links

## Cost

- $20/mo per company, with 100,000 credits a month. The person pays the plan in a browser. You never enter payment details, subscribe, top up or upgrade for them.

## Prerequisites

1. A naïve account. If the person has none, send them to https://app.usenaive.ai/register?blueprint=starter&template=waitlist to sign up, and wait until they say it is done. That page also offers to set this template up in the browser: they can stop once the account exists.
2. A plan, which the person picks and pays in the studio (https://app.usenaive.ai/subscribe), never you. A new company can install first: its install is held until they activate it (see After install).
3. An API key with these six scopes: `agents:read` `agents:write` `sessions:read` `files:read` `files:write` `billing:read`. Why six: the crew needs `agents:read` and `agents:write`. The template's apps get their own key, made from this one, and it needs `sessions:read` `files:read` `files:write` `billing:read`. A key can't give scopes it doesn't have, so without those four the apps and docs are refused.
   The person makes the key in the studio: Settings → API keys → New key (https://app.usenaive.ai/settings), ticking the six scopes. It is shown once. (`naive keys create --name agent --scopes agents:read,agents:write,sessions:read,files:read,files:write,billing:read` also makes one, but only from a CLI signed in with the person's own login, `naive auth login --email`, so normally the person uses the studio.) Have them save it to a file or set `NAIVE_API_KEY` themselves. Never echo, log or commit it.

## First: is it already installed?

Check this before you ask the setup questions. The person may have set it up in the browser already.

```bash
npm i -g @usenaive-sdk/cli
naive --version                         # below 1.1.0 has no `naive install`: use Path B
export NAIVE_API_KEY="$(cat key.txt)"   # a file holding only the key (or the person sets it); it overrides any stored login
naive whoami                            # the organization this key belongs to
naive installs --project waitlist
```

Without the CLI: `curl -sS "https://api.vetta.sh/v1/blueprints/installs?project=waitlist" -H "Authorization: Bearer $NAIVE_API_KEY"` (SDK: `client.apps.installs.list({ project: "waitlist" })`). If it lists a row, the template is installed: skip to After install. If not, go on.

## Setup questions

| key | label | required | type / options | help | example |
| --- | --- | --- | --- | --- | --- |
| `product` | What are you launching? | no | text |  | Ferro, a budgeting app for freelancers |
| `pitch` | One line on why people want it | no | text |  | Know what you can spend, every Monday. |

Ask these after checking it isn't already installed (above). Ask the person for every required answer you do not already know, in one message. Never invent an answer. If an answer doesn't cover what the question's help asks for, ask once more; if they still don't have it, use what they gave and tell them they can change it later (After install). Offer the optional ones once and leave them out if they have none. A list answer repeats its key.

## Path A: the naive CLI

```bash
naive install starter waitlist --project waitlist --dry-run
naive install starter waitlist --project waitlist --new
naive installs --project waitlist
```

1. The dry run writes nothing. It lists the named agents, apps and identity (persona) the install would create. The real run also arms the template's schedules and writes its docs and starter board tasks, and adds a CEO (who owns the board) if the company doesn't have one yet; the preview doesn't show those. Tell the person all of that, and get a yes before the real run, which starts agents that spend credits.
2. `--new` refuses a project that already exists instead of changing it. Add `--new` to the dry run too and it tells you before the real run. Then read the result (below).
- Each answer is `--answer 'key=value'`; a list answer repeats the flag. Leave out an optional question the person has no answer for.
- Advanced: `VETTA_API_BASE_URL` overrides the API host (default https://api.vetta.sh).

## Path B: the SDK or HTTP

```ts
import { createClient } from "@usenaive-sdk/managed-agents";
const client = createClient({ apiKey: process.env.NAIVE_API_KEY! });
await client.apps.installs.preview({ blueprint: "starter", template: "waitlist", project: "waitlist" }); // the dry run: writes nothing, see Path A note 1
const install = await client.apps.installs.apply({ project: "waitlist", blueprint: "starter", template: "waitlist", answers: {  }, expected_revision: 0 });
```

```bash
curl -sS -X POST https://api.vetta.sh/v1/blueprints/installs \
  -H "Authorization: Bearer $NAIVE_API_KEY" -H "Content-Type: application/json" -H "Idempotency-Key: $(uuidgen)" \
  -d '{"project":"waitlist","blueprint":"starter","template":"waitlist","answers":{},"expected_revision":0}'
```

As in Path A: check it isn't installed (above) before the questions, and tell the person what the preview leaves out (the CEO, starter board tasks, schedules, docs) before the apply. An error comes back as `error.code` and its message.

## Reading the result

- `status`: `applied` (created; read `failure` and the exit code, a partial apply is still `applied`), `pending` (still finishing on the server: watch `naive installs --project waitlist`), `held` (waits for the person, see After install), `failed` (`failure` says why).
- Exit 0: everything was created.
- Exit 1: an API refusal, or a partial apply. An `applied` row with refusals (`failure`, or `report` lines with `action: "refused"`) means the company exists but the refused parts don't. Read `next` and `report`, tell the person exactly what was refused, and don't retry blindly. A refusal about missing scopes means a new key with the six scopes (Prerequisite 3). A refusal that names something the platform must set up (such as "not configured") means the person contacts support: they can't fix it themselves.
- Exit 2: a usage problem, such as a missing or unknown answer. Ask the person, then retry.
- `next` appears on the install's own response only, not later in `naive installs`, so save it.

## After install

- An install with `status: "held"` is not a failure: the company is still being set up, and its team starts once the person activates it in the studio. The checkout is theirs. Tell them, and do not retry.
- The studio (https://app.usenaive.ai) opens on the CEO's chat. That is where the person talks to the company.
- Each send waits in the studio until the person allows it. Each post does too, unless an owner or admin chose Always allow for posts.
- The person connects the accounts it posts from to the `owner` persona in the studio (Identities).
- To change an answer: `client.apps.installs.update(install.id, { answers })` (`PATCH /v1/blueprints/installs/{id}`) with the whole map, every answer kept. With the CLI: `naive installs context --project waitlist` prints the answers, and `naive installs context --project waitlist --set key=value` changes one (no clone needed).

## Rules

- Never post, publish or approve anything for the person. Approvals are theirs.
- Never pay, subscribe, top up or upgrade. Show any checkout link verbatim and stop.
- Never build it around a real person, a brand, or work the person holds no rights to.
- On any refusal (exit 1, or an `error` from the API), stop. Tell the person exactly what was refused (`error.code` and message, or the `next` and `report` lines) and ask before you try anything else. Only a usage problem (exit 2) is retried, once the person has answered.
