QUESTPIE
FrameworkCloudAutopilot
AvailabilityDocs
Star on GitHubBuild with QUESTPIE
v3.15.2 · MIT · TypeScript · Bun + Node

Your schema.Your backend.Your admin.One open framework.

Define your data once and get a typed API, admin workspace, auth, jobs and clients from the same TypeScript schema. Self-host the framework today; Cloud and Autopilot are optional products in development.

Self-host
Free · MIT
Adapters
Hono · Elysia · Next · TanStack
Database
Postgres · Drizzle
collections/posts.ts
1export const posts = collection("posts")
2  .fields(({ f }) => ({
3    title:   f.text(255).required(),
4    slug:    f.text(160),
5    status:  f.select([
6      { value: "draft", label: "Draft" },
7      { value: "published", label: "Published" },
8    ]),
9    content: f.richText().localized(),
10    author:  f.relation("user"),
11  }))
12  .admin(({ c }) => ({ icon: c.icon("ph:article") }));
/admin/posts
4 recordsNew
TitleStatusDate
Getting started with QUESTPIEPublishedMay 18
How AI agents run your opsDraftMay 17
Self-host vs managed cloudPublishedMay 14
Building custom collectionsReviewMay 12
QUESTPIE is open source. Star us on GitHub.
The fastest way to support a small team building everything in public.
questpie/questpie
The ecosystem

One framework. Two optional layers.

The open-source Framework is available today. Cloud and Autopilot show the product direction and are not generally available yet.

[01]Available now

Framework

The base layer.

Server-first TypeScript application framework. Define collections once. Get typed API, admin workspace, validation, auth, jobs, and clients projected from one schema.

  • Collections + globals + hooks
  • Drizzle ORM + Zod + Better Auth
  • Hono, Elysia, Next, TanStack adapters
  • MIT. Runs in your codebase
Build your first app
[02]In development

Cloud

Runtime control plane.

A planned managed runtime for QUESTPIE projects. The product direction includes environments, databases, storage, domains, builds and observability.

  • Planned: health-checked deploys + rollback
  • Planned: managed Postgres + storage
  • Planned: custom domains + SSL
  • Plans and limits are not announced
Preview Cloud
[03]Early development

Autopilot

AI-native operating layer.

An operating layer under active development for issues, durable workflows, schedules, knowledge and agent-assisted work.

  • In development: issues + durable workflows
  • In development: schedules + knowledge
  • Planned: agent-assisted app changes
  • Availability and packaging are not final
Explore Autopilot
01 · Framework

Backend architecture, executable.

Instead of manually wiring APIs, admin dashboards and operational tooling, QUESTPIE derives them automatically from your TypeScript schema.

collections/posts.ts
1import { collection } from "#questpie/factories";
2
3export const posts = collection("posts")
4  .options({ versioning: { workflow: true } })
5  .fields(({ f }) => ({
6    title:   f.text(255).required(),
7    slug:    f.text(160),
8    content: f.richText().localized(),
9    author:  f.relation("user").required(),
10    status:  f.select([
11      { value: "draft", label: "Draft" },
12      { value: "published", label: "Published" },
13    ]),
14  }))
15  .access({
16    read: true,
17    update: ({ session, data }) => data.author === session?.user.id,
18    delete: ({ session }) => session?.user.role === "admin",
19  })
20  .hooks({
21    beforeChange: ({ data }) => {
22      if (data.title) data.slug = slugify(data.title);
23    },
24  })
25  .admin(({ c }) => ({ icon: c.icon("ph:article") }))
26  .list(({ v, f }) =>
27    v.collectionTable({ columns: [f.title, f.status] }))
28  .form(({ v, f }) =>
29    v.collectionForm({ fields: [f.title, f.content] }));
Collections
Define data once. Get CRUD API, validation, types, and admin views.
Admin workspace
Production-ready UI from your schema. Custom fields, access control, i18n.
Auth & RBAC
Better Auth built-in. Roles, OAuth, field-level permissions.
Jobs & workflows
Background tasks, scheduled jobs, durable workflows that survive restarts.
Adapter-first
Storage, cache, queue, search, email. Swap for what you already use.
End-to-end types
Schema → Drizzle columns → Zod → typed clients. No glue code.
Modules
Extension unit. Add collections, routes, services, views. Autopilot itself is a module on top.
Codegen + introspection
Plugin-driven codegen produces typed clients, OpenAPI, admin metadata from one schema.
Built for production
i18n built-in
Mark a field `.localized()` and it lives in a per-locale i18n table. Fallback chain, admin locale switcher, typed queries.
Typed live queries
Every mutation writes to an outbox; pg_notify or Redis Streams fan out. Subscribe with typed `live()` snapshots, or pass `{ realtime: true }` to a TanStack Query and it streams.
Versioning + workflow
Opt into versioning per collection. Draft → review → published transitions. Revert to any version. Full audit trail.
Blocks · page builder
`f.blocks()` field type. Define block schemas server-side, register React renderers client-side. Server prefetches data for SSR.
Boot-validated env
Declare vars once in `env.ts`. Validation runs at boot, before adapters, auth or the DB initialize. Client-safe vars ship via codegen — server keys physically absent.
Atomic claims
`updateMany` re-checks `where` under row locks and returns exactly the rows it wrote. Losing a concurrent claim is an empty array, not silent corruption.
Server-enforced validation
`.required()`, `.min()`, custom `.zod()` refinements — every field rule is enforced in the API layer on every write, not just in the admin UI.
Typed escape hatches
`.zod()`, `.$type<T>()` and `.drizzle()` tweak the schema, the TypeScript type and the column per field without leaving the field DSL.
Plug into your stack
One adapter line. The same typed app.
server.ts
1import { Hono } from "hono";
2import { questpieHono } from "@questpie/hono/server";
3import { app } from "#questpie";
4
5const server = new Hono();
6server.route("/api", questpieHono(app));
7
8export default { port: 3000, fetch: server.fetch };
One schema, many projections
Codegen turns your collection into everything around it.
Input
collection("posts")
  .fields({...})
  .hooks({...})
  .access({...})
  .list(v.collectionTable)
  .form(v.collectionForm)
$ questpie generate
REST API
GET / POST / PATCH / DELETE on /posts. Pagination, filtering, sorting.
Drizzle schema
Typed Postgres columns + indexes + FK constraints.
Zod validators
Input + output schemas, enforced server-side on every write.
Admin list + form
Server-driven views with filters, search, tabs, sidebar.
TypeScript types
`AppCollections["posts"]` exact shape across server and client.
OpenAPI + SDK
Auto-published OpenAPI. Typed client. TanStack Query hooks.
MCP tools
CRUD exposed to agents under the same RBAC. No prompt glue.
Live queries
Typed live() snapshots over SSE. `{ realtime: true }` streams into TanStack Query.
Start with the docsStar on GitHub$ bun create questpie my-app
02 · Cloud

A managed runtime in development.

This is a product preview, not a generally available service. The direction is managed environments, databases, domains, builds and rollouts for QUESTPIE projects.

Cloud product concept / illustrative datapreview
Last 7 days
127
Deploys
84ms
p95
Illustrative
Uptime
0 failed
Builds
Project · branchStatusTime
marketing-site prodlive2m ago
blog prodlive1h ago
marketing-site preview/feat-pricingbuilding3m
internal-tools prodliveyesterday
Cloud product concept · illustrative projectpreview
Environments
prod · marekstreet.barbersok
staging · staging.marekstreet.barbersok
preview/feat-pricing · preview-feat-pricing.questpie.appstep 3/6
Resources
Postgresshared-eu · 16 GB
Storage5.2 GB · S3-compat
Emailsend · verified
Domains2 · SSL auto
hosted Autopilot · mappedmarekstreet.autopilot ↗
Health-checked deploys
Planned: health checks, controlled rollout and rollback for managed deployments.
Managed Postgres + storage
Planned: managed project databases and object storage. Limits are not announced.
Custom domains + SSL
Planned: project domains, certificate provisioning and managed routing.
Preview deploys per branch
Planned: isolated preview environments tied to project branches.
Hosted Autopilot per account
Product direction: optional Autopilot integration for managed projects.
Logs, metrics, alerts
Planned: deployment logs and health signals in one project view.
Backups + audit
Under evaluation: backup, restore and operational audit capabilities.
Team roles + SSO
Under evaluation: project membership and access controls. No enterprise plans are announced.
Cloud · Product preview
See the current direction, scope and availability notes before deciding whether it fits your roadmap.
Read the Cloud preview
03 · Autopilot

An operating layer in development.

Autopilot is an early product direction for issues, durable workflows, schedules, knowledge and agent-assisted work. The preview below is not a promise of general availability or final packaging.

workflows/onboard-customer.ts
1// workflows/onboard-customer.ts · durable, restartable
2export default workflow({
3  name: "onboard-customer",
4  schema: z.object({ email: z.string() }),
5  handler: async ({ input, step }) => {
6    const user = await step.run(
7      "create-account", () => createUser(input.email)
8    );
9
10    await step.run("welcome", () => sendWelcome(user));
11    await step.sleep("trial", "14d");
12    await step.waitForEvent("decision", { event: "trial-end" });
13    await step.invoke("renewal", {
14      workflow: "send-renewal", input: { user },
15    });
16  },
17});
Workflow primitives
step.runexecute + persiststep.sleepwait hours/days/weeksstep.waitForEventblock on signalstep.invokecompose workflows
agent · content-team-01running
Run · #4821
step.draft-post01.4s
Generated 612 words
step.fact-check03.1s
3 sources verified
step.seo-pass00.9s
title + meta updated
step.human-review·
Waiting for @marek
step.publish·
Will run after approval
trace: wf_a821-04283 / 5 steps · 5.4s
Issues
Linear-style work items with status, type, project and attached workflow.
Workflows
Durable procedures. step.run · step.sleep · step.waitForEvent · step.invoke.
Schedules
Cron triggers that create issues or run workflows directly.
Knowledge
Context, docs and rules with semantic search. Used by workflows and agents.
AI builder
Lovable-style. Modifies real QUESTPIE code, opens a PR, deploys through Cloud.
Agents
Capability profiles + tools + MCP. Pluggable provider. Anthropic, OpenAI, local.
Integrations
Slack, GitHub, email. Open issues from a thread. Approve workflows in one click.
Packs
Installable bundles: skills, workflows, schedules, MCP tools, knowledge seeds.
Agent runtimes
Runtime compatibility is being evaluated.
MCP · spawn-agent · streaming
Claude Code
Evaluating
Codex
Evaluating
Gemini
Research
Cursor
Research
OpenCode
Research
Copilot
Research
Autopilot · Product preview
See the current direction, scope and availability notes before deciding whether it fits your roadmap.
Read the Autopilot preview
For real businesses

A framework for real application models.

These are examples of what teams can build with the available Framework. They are starting points, not prebuilt vertical products or benchmark claims.

Architecture

What is available and what is next.

Framework and QProbe are available today. Autopilot and Cloud are shown as product direction, with final scope and availability still to be announced.

Surface
Your site & internal tools
Public site
Admin workspace
API & SDKs
Docs site
FrameworkLIVE
Open source · MIT
Collections + admin
Auth + RBAC
Jobs + workflows
Adapters
AutopilotEARLY
Product direction
Issues + workflows
Planned AI builder
Agent research
Knowledge direction
QProbeLIVE
Verification layer
Run app locally
Drive browsers
API checks
Evidence for runs
CloudPREVIEW
Planned managed service
Planned deployments
Planned data services
Planned domains
Integration direction
PostgreSQL · Drizzle ORM · Zod v4·Better Auth · pg-boss · Files SDK·React 19 · Tailwind v4 · shadcn·Bun / Node
Availability

Framework now. Cloud and Autopilot when ready.

Only the Framework is generally available today. Pricing, limits and launch dates for Cloud and Autopilot have not been announced.

Available now
Framework
FreeMIT

The open-source framework, available to self-host today.

Build your first app
  • Collections, globals, routes and jobs
  • Schema-driven admin and typed clients
  • Auth, access rules, hooks and validation
  • All adapters (Hono / Elysia / Next / TanStack)
  • Cloud service
  • Autopilot product
Cloud
PreviewIn development

A planned managed runtime for QUESTPIE projects.

Read the Cloud preview
  • Planned: managed environments
  • Planned: databases and storage
  • Planned: domains and deployments
  • Pricing is not announced
  • Limits and SLA are not announced
Autopilot
EarlyIn development

An operating layer for workflows and agent-assisted work.

Read the Autopilot preview
  • In development: issues and workflows
  • In development: schedules and knowledge
  • Runtime compatibility is being evaluated
  • Availability is not announced
  • Packaging and licensing are not final
FAQ

Questions, answered.

Honest answers. No marketing fluff. Want to follow the product direction? Read the Cloud preview.

Framework is the open-source TypeScript application framework and is available today. Cloud is a planned managed runtime, and Autopilot is an operating layer in early development. Their pages describe product direction, not generally available services.

The QUESTPIE Framework repository is MIT-licensed. Cloud is a planned managed service. Autopilot packaging and licensing will be documented before broader availability; this page does not promise a license for an unreleased product.

Yes. The Framework runs in your application and supports Hono, Elysia, Next.js and TanStack Start adapters. Cloud portability details will be documented when that service has a stable contract.

Hosted platforms own your schema, your data and your operational tooling. QUESTPIE inverts that. Your code defines the schema, and the admin, API and workflows are generated. You stay in TypeScript, in version control, in your codebase.

Autopilot is not generally available. Its permission, audit and approval model is still being validated. Security guarantees and deployment guidance will be documented before broader access.

Runtime compatibility is under evaluation. Supported providers and their limitations will be documented as part of early-access releases rather than promised here.

No general-availability date is committed. The Framework ships today; Cloud and Autopilot will publish availability, pricing and support terms when those contracts are ready.

Build with the Framework today.

One schema. A backend you own.

Start with the open-source Framework today. Cloud and Autopilot are separate products in development, with availability still to be announced.

$ bun create questpie my-app·cd my-app·bun dev