What are you building?

Architect your conceptual backend in minutes.

Try: "A marketplace with items and reviews" or "A social app with following and posting"

✓ Both repos are yours ✓ Tested before it's done ✓ Payments, email & AI built in
Five real apps below, one prompt each
The gallery

Five real apps, backend and all. One prompt each.

Every app below was generated from the single prompt shown on its card. Expand the prompt, then click through and use the app live. Commons ships twice: v1, then v2 after one iteration, with the diff to prove nothing else moved.

deskmind.conceptual-ai.app

Deskmind

Also our real support desk

An AI support inbox: automatic triage, draft replies grounded in your own help docs, and real two-way email, on a backend you own.

Would quote 74 credits ($222) to build today

AI triage & drafts RAG over your docs Two-way email Operator admin File uploads
See the prompt that built it

This exact prompt, nothing else, built this app.

Build an AI-powered customer support inbox for a small support team.

There are two kinds of people using the app. The support team's operator signs in with operator credentials configured in the environment — there is no operator signup page. Support agents register with email and password and have a profile with a name and an avatar image they can upload, but registering alone gives no access to the inbox: the operator must approve (promote) a registered account to agent before it can see or work on support requests, and the operator can revoke an agent's access later. There is also a public page where customers can submit a support request without logging in — they enter their email, a subject, a message, and can optionally attach a file or screenshot. After submitting, a customer can return to the public page and look up their own request(s) by entering the email address they used — no account needed — to see the current status and the full conversation, and to post a follow-up reply on their request (the follow-up is identified by that email).

When a new support request arrives, the system automatically uses AI to process it: it classifies the request into a category (Billing, Bug, Feature Request, or Other), assigns a priority (Low, Medium, High, or Urgent), extracts structured fields from the message into a side panel (order number, product name, customer sentiment, and the specific action the customer is requesting), and screens the message for abusive or threatening language, flagging it with a short written reason when it violates policy.

Logged-in agents see an inbox list of all requests sorted by priority, with the category and a flag indicator shown on each row. Clicking a request opens it to show the full message, any attachment, the AI-extracted fields, and the AI moderation verdict. Agents can write internal notes on a request that only other agents can see, and they can post a reply to the customer — and that reply is sent to the customer as a real email from the team's support email address. The customer's own replies (whether posted via the public lookup page or received by email) are threaded back into the same request so agents and the customer see one continuous conversation. There is an "AI draft reply" button that generates a suggested reply; the suggested reply must be grounded in help-center documents that agents upload (policy and FAQ documents), so answers are based on the team's real policies rather than guesses. Agents can edit a draft before sending and can mark a request as resolved.

Agents get a notification when a new High or Urgent request arrives.
  • Submit a real support request. This is ConceptualAI's actual support desk, so it reaches us
  • Ask anything about ConceptualAI. Answers are grounded in our help docs and arrive as a real email
  • Come back later, look up your request by email (no account needed), and post a follow-up; it threads into the same conversation
  • Behind the curtain, staff-side: AI classifies, prioritizes, extracts details, and drafts doc-grounded replies for our team
atelier.conceptual-ai.app

Atelier

A visual booking marketplace: photo listings, schedules that can’t double-book, and a natural-language booking assistant.

Would quote 31 credits ($93) to build today

AI booking assistant Scheduling & reservations Messaging Reviews Media
See the prompt that built it

This exact prompt, nothing else, built this app.

Build a visual marketplace for booking creative classes and studio sessions (for example pottery, photography, music, or cooking classes).

Users register with email and password, log in, and create a profile with a display name, a short bio, and an avatar image they can upload. Any user can act as a host or a guest.

Hosts create listings. A listing has a title, a description, a category, a location, a price, and one or more photos the host uploads. For each listing, the host publishes available time slots that guests can book.

Guests browse a visual grid of listings with their photos and can filter by category. Opening a listing shows its photos, details, available time slots, and reviews. A guest books an available time slot; the system must prevent two guests from booking the same slot. There is also a natural-language booking assistant: a guest can type a request like "find me a pottery class next Saturday morning" and the assistant finds matching listings and available slots and books one for them.

When a booking is made, a private message thread between the guest and the host is started for that booking, and that is where they arrange payment and any session specifics — the app itself does not process payments; the listing's price is what the host communicates and collects directly. After a session, a guest can leave a star rating and a written review on the listing. Users get a notification when they receive a new booking or a new message.

A host can delete one of their listings. When a listing is deleted, all of its time slots, bookings, reviews, and message threads connected to it are removed as well, leaving no orphaned data.
  • Scroll the photo grid and filter by category
  • Type "find me a pottery class next Saturday morning"; the assistant finds and books a slot
  • Booking opens a private message thread with the host
  • Try to double-book a taken slot; the server refuses
commonsv1.conceptual-ai.app

Commons

v1 ⇄ v2, one iteration apart

A paid community with Stripe supporter subscriptions. Then one iteration adds AI moderation without touching the billing.

Would quote 46 credits ($138) to build today

Stripe subscriptions Admin dashboard Social feed Media v2 adds: AI moderation
~ Posting, Commenting: patched + AIModeration: added = Subscribing, Liking, Following + 6 more: unchanged, byte-for-byte
See the prompt that built it

This exact prompt, nothing else, built v1.

Build an image-sharing community app with a paid supporter tier.

Users register with email and password, log in, and create a profile with a display name, a short bio, and an avatar image they can upload.

Users create posts that consist of an uploaded photo and a caption. There is a home feed that shows posts from the people the user follows, and a separate discover feed that shows recent posts from everyone. Users can like a post and leave comments on a post. Users can follow and unfollow other users. Opening a user's profile shows their posts, their follower count, and a follow button.

Users can become supporters by subscribing to a monthly supporter plan through a secure hosted checkout page. A user can mark any of their posts as supporters-only. Supporters-only posts are shown in full only to users with an active supporter subscription; everyone else sees a locked placeholder instead of the photo. A user can cancel their subscription from a billing page, and when the subscription ends their supporter access ends with it.

There is a site operator (admin) who signs in with operator credentials configured in the environment — there is no admin signup page. The admin has a dashboard that shows recent posts and members and lets the admin remove a post.

A user gets a notification when someone likes their post, comments on their post, or follows them.

The v2 iteration prompt, the only change request between v1 and v2:

Add AI moderation that screens every new post and every new comment before it becomes public. If the content violates community guidelines — harassment, hate, sexually explicit material, or spam — block it from the feeds and show the author a clear message explaining which rule it broke. Add a moderation queue page to the admin dashboard that lists every flagged item together with the AI's written rationale, and lets the admin approve an item back onto the feed or permanently remove it.
  • Subscribe with the Stripe test card; a locked supporters-only post unlocks
  • On v2, try posting abusive text; it’s blocked with a written reason
  • Open the admin moderation queue: every flagged item with the AI’s rationale
  • Compare v1 and v2: the Subscribing concept and the Stripe utility are byte-for-byte identical

Test mode: card 4242 4242 4242 4242

stride.conceptual-ai.app

Stride

An AI training coach that shows its sources: web-research-grounded plans that adapt to your daily feedback.

Would quote 31 credits ($93) to build today

Live web research + citations AI plan adjustments Daily check-ins Notifications
See the prompt that built it

This exact prompt, nothing else, built this app.

Build an AI training coach app.

Users register with email and password, log in, and have a profile with a display name and an avatar image they can upload.

A user sets a training goal by telling the coach, in their own words, what they want to achieve, the date they want to achieve it by (for example "run a sub-20-minute 5K by October 1st"), and their athletic stats (for example age, weight, experience level, and recent performance numbers). A user can have only one active goal at a time; they can abandon their active goal, and only then set a new one.

When a goal is set, the AI builds a day-by-day workout plan running from today through the goal date, optimized toward the goal given the user's stats. The plan must be grounded in real research: the AI runs web research on the training approach for this kind of goal and attaches the cited sources it relied on, so the user can see the evidence behind the plan's structure and exercise choices.

The main view is a calendar showing each day's workout. Opening a day shows that workout's details — the exercises with sets and reps, or duration and intensity — plus the research-backed rationale and its cited sources.

After doing (or skipping) a day's workout, the user gives feedback on that day: a quick rating of how it went and an optional written note (for example "this was too easy" or "my knee hurt on the lunges"). The AI then adjusts the remaining future days of the plan based on the feedback — past days are never changed.

The user gets a notification when their plan is generated and whenever the plan is adjusted after feedback.
  • Set a goal like "run a sub-20-minute 5K by October 1st" with your stats
  • The calendar fills with a day-by-day plan. Open a day to see the cited sources behind it
  • Rate today’s workout "too easy"; future days adjust, past days never change
shopfront.conceptual-ai.app

Shopfront

A real store: cart checkout with Stripe, inventory that can’t double-decrement, and confirmation emails sent exactly once.

Would quote 18 credits ($54) to build today

Stripe checkout Order emails Inventory integrity Owner admin Media
See the prompt that built it

This exact prompt, nothing else, built this app.

Build an online store app for a single business.

The business owner signs in with operator credentials configured in the environment — there is no owner signup page. The owner manages the store's catalog: each item has a name, a description, a price, one or more photos the owner uploads, and a stock count. The owner can add stock to any item at any time.

Customers do not need an account. They browse a visual grid of the items with photos and prices. An item whose stock is zero is shown grayed out as sold out and cannot be purchased.

Customers add items to a cart, choosing a quantity for each, and check out the whole cart in one payment through a secure hosted checkout page. At checkout the customer provides their email address and their shipping address. Checkout must not go through for a quantity larger than an item's available stock, and sold-out items can't be checked out at all — the stock rules are enforced by the server, not just the page.

When an order's payment completes, exactly once: each purchased item's stock goes down by the quantity bought (an item that reaches zero becomes sold out), the order is recorded with its items, quantities, the customer's email, and the shipping address, and a confirmation email listing the order's contents and shipping address is sent from the store's own email address to both the customer and the business owner. A duplicate or replayed payment notification must not decrement stock twice or send the emails twice.

The owner has an orders page listing orders newest-first with their items, quantities, shipping details, and payment status, and gets a notification when a new order arrives.
  • Add 2 of an item with stock 3 to your cart and check out with the Stripe test card
  • Stock drops to 1 and two confirmation emails go out: customer and owner
  • Buy the last unit: the card grays out "Sold out"; the server enforces stock, not the page
  • Replayed payment webhooks can’t decrement stock twice or double-send email

Test mode: card 4242 4242 4242 4242

The receipts

How we know the backend works before you get it.

The most common complaint about AI app builders is that adding a feature quietly breaks the last one. That damage happens in the backend (data, auth, payments, the state everything else depends on), so that is where the rigour goes. Your backend is assembled from pre-tested building blocks, and each concept it is built from isn't accepted until its own generated tests pass against a real database. The interface is generated against that finished API and reviewed against it, which is the part models are reliably good at. Instead of promises, you get receipts where they matter.

Test receipt Deskmind: generated with the app, shipped in its repo
$ deno test --allow-all
running 161 tests from Deskmind-backend
SupportRequests › triage sets category and priority… 16 ok
Emailing › reply delivered exactly once… 16 ok
HelpDocuments › draft grounded in uploaded docs… 14 ok
MediaHosting › upload stored and retrievable… 14 ok
Sessioning › revoked agent loses access… 11 ok
125 concept tests passed against a real database at build time · 161 ship in the repo
865 generated tests across our six public demo backends. Clone one and count.
Iteration diff receipt Commons v1 → v2
~ Posting patched
~ Commenting patched
+ AIModeration added
unchanged, byte-for-byte:
= Subscribing
= Liking
= Following
= Authenticating
= Sessioning
= Profiling
= MediaHosting
= Notifying
= AdminAuthenticating

Add a feature; get proof the rest didn't move, including the Subscribing concept.

Security receipt the failure modes AI-built apps are famous for, closed by construction
No keys in the browser
$ grep -r "sk_live" frontend/dist | wc -l
0

Keys live in backend/.env, documented by a generated .env.template. The browser gets a session cookie, never a secret.

No database exposed to the client
browser backend API your database
direct client → database access: none

No client-side database access means no row-level security to misconfigure. The rules live in the backend you own.

No admin signup route
ADMIN_USERNAME= # set on your server
ADMIN_PASSWORD=

Operators sign in with environment credentials; there is no admin registration endpoint to discover.

Verification is never AI-written
POST /webhooks/stripe
signature verified ✓ (raw body)
evt_9f3k2 replayed → ignored
applied → syncs fire

Untrusted events are verified, deduped, and applied exactly once by a human-authored, tested block. Generated code only reacts to the verified result.

Everywhere the industry's horror stories come from (secrets, auth, webhooks, database exposure) is human-authored library code that was tested before your app existed. The AI composes it; it doesn't reinvent it.

~17,800
lines of backend code
~10,300
lines of frontend code
~12,400
lines of generated tests
2,866
lines of API documentation

All from the one prompt on Deskmind's card above: the AI support inbox that's live as our real support desk.

How it works

How a plain description becomes a working app.

You shape what gets built; the machine does the building and the checking; you keep the result.

1Step
Shape the plan
Describe the app in your own words. The AI turns it into a plan you can read and edit. Nothing gets built until you’re happy with it.
2Step
We build it
On our servers, on our AI keys: building blocks assemble, the connections between them are generated, and a test suite runs against a real database. You watch the progress live.
3Step
It’s yours
A full-stack app: Deno backend, React frontend, tests, OpenAPI docs, Dockerfile. Preview it live, export both repos to GitHub, deploy anywhere. Iterate any time in plain language: we patch our copy, re-run the suite, and re-export both repos, with a diff receipt showing exactly what changed and what didn’t. Edits in your own repos stay yours.
Code you actually own

You own the source code. Both repositories.

Every build hands you two clean repositories: a Deno backend with the generated tests, the OpenAPI spec and a Dockerfile inside, and a React frontend built against that same spec. Export straight to GitHub, run locally, deploy anywhere. No proprietary runtime. No SDK between you and your backend.

One-click GitHub export, both repos MongoDB · Postgres · Turso, your call Backend ships tests, OpenAPI docs & Dockerfile Every demo repo: one commit, untouched since export ✓ Run locally or deploy yourself
your repositories
backend/
deno
backend/
  src/
    concepts/
    syncs/
    main.ts
  tests/
  openapi.yaml
  Dockerfile
  .env.template
  deno.json
frontend/
react + vite
frontend/
  public/
  src/
    pages/
    components/
    App.tsx
    main.tsx
  package.json
  vite.config.ts
Real integrations

Real integrations: payments, email, AI, and your database.

Payments that settle, email that sends, AI that's part of the product, research with sources. Every badge below links to a live demo that proves it. Nothing here is a roadmap item.

The building blocks

Built from a tested library, not improvised token by token.

Apps here aren't improvised token-by-token. They're assembled from a versioned library of building blocks: each one human-authored, individually tested, and already shipped inside earlier apps. The AI spends its generation on the connections between blocks, not on reinventing auth or billing.

Concepts: the behaviors
AuthenticatingSessioningProfiling PostingCommentingLiking FollowingSubscribingPurchasing EmailingNotifyingMediaHosting ResearchingWebSearchingAdminAuthenticating 56 versioned concepts, every one with its own tests
Provider utils: the integrations
stripegithubemail aiwebsearchgoogle admin
Adding a provider is one file
library/utils/<provider>/<provider>.ts

  real strategy:  calls the provider, keys from env
  mock strategy:  runs in tests & previews, no keys
  .env.template:  every variable it needs, documented

An integration is a single TypeScript utils module with a live strategy and a mandatory mock. Publish it to the library once, and every app built afterward can be assembled with it: same tests, same receipts.

Today the library grows through our own pipeline: Stripe, GitHub, email, AI, and web research all entered this way. Community contributions are on the roadmap, and the ingestion path they'll use is the one we already run.

The obvious question

Why not just use a coding agent?

If you're technical enough to want two repos and a Dockerfile, you could point Claude Code or Cursor at a template. Four honest reasons this is different:

Assembled, not improvised
An agent writes your auth, billing, and bookings from scratch, every time, and hopes. Here those are versioned library blocks that have shipped before; generation is spent on the connections, not the foundations.
"Done" has a definition
An agent is done when it stops typing. Here, a concept isn't done until its own generated tests, hundreds of them, pass against a real database.
Iteration comes with proof
Ask an agent for one more feature and hope nothing broke. Ask here and get a diff receipt: what changed, what is byte-for-byte identical, including the Subscribing concept.
Many cheap calls, not one expensive loop
A coding agent runs everything through one frontier model, and the bill grows with every retry. Here the work is split across many small, specialised calls, most of them on cheap models, with the expensive ones saved for the parts that need them. You see it in the price, and you are quoted before anything runs.

And if you love your coding agent: the export is a clean repo with a tested backend it can keep working on. Plenty of people use both.

Fair questions

Questions about the code, the database, and hosting.

Why Deno on the backend?

It's standard TypeScript with npm compatibility: a Node developer can read and extend it immediately. The runtime buys default-secure permissions and zero build ceremony, and the included Dockerfile means it runs anywhere a container runs: your VPS, Fly, Cloud Run, or Deno Deploy with the included guide.

Do I still need your servers after export?

No. The repos are self-contained: install Deno, put your database URL in .env, run the task. No proprietary runtime, no SDK between you and your backend, nothing phones home.

Where do secrets live?

In backend/.env on your infrastructure, filled in from a generated .env.template that documents every variable. The frontend bundle ships zero keys, and operators sign in with environment credentials; there is no admin signup route.

Which databases can it use?

MongoDB, Postgres, or Turso. Your exported backend runs on any of the three by changing one environment variable. No code changes, because the data layer is written against all three.

What if I've hand-edited my exported code?

Your edits live in your repos and stay yours. Platform iterations patch our copy, re-run the suite, and re-export, so pulling an iteration into your fork is a normal git merge, not archaeology.

Start with a prompt. Keep the code.

Open the builder and start your first app.

Free to sign up, no card required. Every build is quoted before it runs.

Open Builder →
Have a question? Our support desk is Deskmind, an app this platform built. Same one as in the gallery. Open support ↗