Solutions · Cloud Infrastructure

Ship apps and infrastructure from one API.

Provision Vercel-hosted apps with a managed Supabase backend — database, storage, edge functions, and auth — plus raw Docker compute and SQS work queues, without ever holding a provider key.

Get your API keyRead the docs
Zero-setup install

Let your agent set it up

Skip the manual wiring. Drop this prompt into your coding agent and it reads the skill, then integrates Naïve for you.

$ Read https://usenaive.ai/skill.md and use it to set up Naïve in my project.

Drop into any agent

Primitives

Infrastructure primitives, fully managed.

Naïve owns the Vercel and Supabase credentials and scopes every call to your app's own project.

Apps

Vercel-hosted Next.js apps with deploys and domains.

Read docs

Database

Managed Postgres — raw SQL, PostgREST CRUD, migrations.

Read docs

Edge Functions

List, deploy, and invoke serverless functions.

Read docs

Storage

File storage buckets and objects, per app.

Read docs

Compute

Run Docker containers, workers & scheduled jobs (ECS/Fargate).

Read docs

Queue

Durable SQS work queues for agent pipelines.

Read docs
Exact code

Provision and deploy in a few calls.

The same primitives power your own apps and each of your end-users' apps via forUser(id) — one bearer token.

POST /v1/apps

Apps

Each app is a real Vercel project plus, for fullstack apps, a dedicated Supabase project. Create, deploy, and promote to production from the CLI or API.

Vercel Hosting
Next.js projects, deploys, domains.
Supabase Backend
Postgres, auth, storage, functions.
One-Click Deploy
Upload and publish to production.
Managed Credentials
No Vercel or Supabase account.
# Create a fullstack app (Vercel + Supabase)
$ naive apps create --name "StudyAI" --type fullstack

# Deploy from your project directory
$ naive apps deploy <app-id>

# Promote a deployment to production
$ naive apps publish <app-id> --deployment <deployment-id>
POST /v1/apps/:id/db/query

Database

Managed Postgres backed by the app's Supabase project. Run raw SQL, read and write rows through PostgREST, and apply migrations — Naïve injects the credentials.

Raw SQL
SELECT, DML, and DDL.
PostgREST CRUD
insert / select / update / delete.
Migrations
DDL via naive.database.migrate.
Multi-Tenant
Per-user DBs via forUser(id).
# Inspect tables, then run SQL on the app DB
$ naive apps db tables <app-id>

$ naive apps db query <app-id> "SELECT count(*) FROM users"

$ naive apps db query <app-id> "CREATE TABLE notes (id serial primary key, body text)"
SDK · fullstack backend

Storage, Auth & Functions

A fullstack app's Supabase project is exposed as first-class primitives — storage buckets, edge functions, and admin auth — usable for your own app or, via forUser(id), each end-user's app.

Storage
Buckets and objects.
Edge Functions
List, deploy, invoke.
Auth
Config and admin users.
Secrets
Encrypted env, synced to Vercel.
# Manage secrets + reach the Supabase backend
$ naive apps secrets set <app-id> PAYMENTS_KEY sk_live_... --target production

$ naive apps supabase <app-id> GET "v1/projects/<ref>/functions"
POST /v1/compute

Compute

Run agent-owned Docker workloads on managed cloud compute (ECS/Fargate): long-running services with an optional public URL, run-to-completion jobs, and cron-for-code schedules. Billed by the second, scale to zero on demand, with an interactive shell — no AWS account.

Services
Long-running container + URL.
Jobs & Schedules
Batch + cron-for-code.
Interactive Shell
naive compute ssh (ECS Exec).
Per-Tenant Isolation
microVM + scoped IAM role.
# Long-running service (optional public URL)
$ naive compute create --name bot --type service --image ghcr.io/me/bot:latest --port 8080

# Cron-for-code, logs, and a shell
$ naive compute create --name nightly --type schedule --image me/etl --schedule "cron(0 9 * * ? *)"

$ naive compute logs <id>
$ naive compute ssh <id>
POST /v1/queue

Queue

Durable work queues backed by managed Amazon SQS — standard or FIFO, with optional dead-letter queues. Producer/consumer fan-out, buffering, and at-least-once retries; the natural pairing for compute workers.

Standard & FIFO
At-least-once or exactly-once.
Send / Receive / Ack
Long-poll with receipt handles.
Dead-letter Queues
Capture repeated failures.
Worker Pattern
Pairs with a compute service.
# Create a queue, then produce + consume
$ naive queue create --name jobs

$ naive queue send <id> '{"task":"resize","url":"https://..."}'

$ naive queue receive <id> --wait 20
$ naive queue ack <id> <receiptHandle>

Build your cloud on one control plane.

Spin up apps, databases, functions, containers, and queues for every agent and tenant — no DevOps required.

Get your API keyRead the docs