Guide

AI App Maker With No Backend

Most weekend apps were never going to need a database. Here is why mk0r is one of the only AI app makers that ships frontend-only React by default, and how to verify the app you just built does not have a server stapled to it.

m
mk0r
7 min
4.8from weekend builders
Vite + React scaffold, zero server code in the box
localStorage and useState by default, no auth flow
Static bundle on publish, hostable from a USB stick

The phrase quietly means two different things

People typing this into Google fall into two camps and they are not the same camp. The first wants a tool that hides the backend from them: signup, auth, database tables, role permissions, all of it generated and managed automatically so they never see a SQL statement. The second wants a tool that does not generate a backend at all: a small, single-user app with state in the browser, exported as a static bundle, no server to keep running.

Most articles on this topic only answer the first reading. They list Lovable, Base44, Appy Pie, Glide. Those tools are good at the first reading and bad at the second one, because their default behavior is to spin up a Postgres or Firestore project the moment you start typing. If your goal is a Pomodoro timer or a habit tracker for yourself, that is overkill, and the lock-in lasts for as long as you keep using the app.

mk0r is set up for the second reading. The default is no server. The agent only reaches for the database when the request you typed actually requires one.

What is actually inside the mk0r scaffold

Every mk0r session boots an E2B sandbox with a Vite + React + TypeScript project pre-installed at /app. Tailwind CSS v4 is wired in. Playwright is installed for browser testing. The dev server runs on port 5173. That is everything.

The project's CLAUDE.md file lists exactly four files the agent is told never to modify, because they are scaffold plumbing rather than product code:

Files the scaffold ships with

  • vite.config.ts — dev server config and HMR proxy
  • src/main.tsx — React entry point
  • src/_mk0rBridge.ts — HMR lifecycle bridge to the preview frame
  • src/index.css — Tailwind v4 import

Notice what is not on that list. There is no Express server. No Next.js API route. No Convex client, no Supabase wrapper, no Hono handler, no tRPC router, no Drizzle schema, no Prisma file. The only file in the scaffold that runs anywhere besides your browser is _mk0rBridge.ts, and it is doing one job: forwarding Vite HMR events to the preview parent window so the iframe can show the user that the app just hot-reloaded.

docker/e2b/files/app/src/_mk0rBridge.ts

Twenty-eight lines. Every one of them is window.parent.postMessage plumbing. There is no fetch, no API URL, no analytics beacon, no auth token. When you ship the app, this file gets bundled into the static output and continues posting messages to whatever frame embeds it (your published domain has no parent frame, so the calls become harmless no-ops).

The shape of an mk0r request when nothing needs a server

A typical Reddit-style prompt: "build me a habit tracker that remembers what I checked off, with a dark mode toggle." Two requirements: persistence and a UI toggle. Neither requires a server. Persistence becomes localStorage, dark mode becomes a class on the root element, the whole thing fits in one component file. Here is what mk0r writes:

src/App.tsx (mk0r output)

Compare with what an AI builder that defaults to spinning up a backend project does for the exact same one-line prompt:

api/habits/route.ts (other tools)

One of these you can save to disk, drop into a Cloudflare R2 bucket, and use forever without a credit card. The other one quietly creates a Postgres database, ties your habit data to a user_id you can never export cleanly, and stops working the moment the vendor changes their free tier.

Where the request flows when you do not ask for a server

No-backend mode: nothing leaves the browser tab

Click handler
Form submit
Keyboard event
React state
DOM update
localStorage
IndexedDB

Notice what is missing from the diagram: there is no node labeled "API server," no node labeled "auth provider," no node labeled "database." The hub is useState. The destinations are all browser-local. This is the default flow for any mk0r app where the prompt did not explicitly ask for cross-device sync, multi-user, login, or shared data.

How to verify the app you just built has no backend

Run these three checks against any AI-generated app, mk0r or otherwise. If all three come back clean, the app is genuinely frontend-only.

Backend audit on a generated app

What a backend-free build actually buys you

0server processes
0the only port in use
0scaffold infra lines
0%data on your device

The 5173 in that row is the Vite dev server port inside the E2B sandbox. When you publish, even that goes away: the build step collapses everything into a static dist/ folder that any CDN, static host, or filesystem can serve. The 28 lines are the entire _mk0rBridge.ts file, which is dev-only plumbing for the preview iframe; the production bundle does not need it.

mk0r vs the other AI app makers in this category

FeatureMost other AI app buildersmk0r
Default state on a fresh promptBackend project + tables + auth scaffoldedFrontend-only React, useState, no fetch
Persistence for a habit trackerPostgres row keyed to user_idlocalStorage, JSON stringified
What ships when you publishStatic bundle + hosted server + databaseStatic React bundle, no server
Server framework in package.jsonexpress, hono, next, or similarJust react, react-dom, vite, tailwindcss
Account required to use the builderYes, with a verification emailNo, anonymous sessions work
Where your app's data livesVendor's database, often hard to exportUser's browser, exportable as JSON
Becomes a backend app on demandAlready is oneYes, when you ask for cross-device sync

Behavior reflects the public marketing pages and default flows of each tool as of 2026-04-25.

Apps that are a perfect fit for the no-backend default

A non-exhaustive list pulled from the kinds of prompts mk0r sees most often. None of these need a database to be useful, and forcing one onto them mostly adds friction:

Habit and streak trackers
Pomodoro and focus timers
Personal calculators (BMI, mortgage, tip)
Study flashcards and quiz tools
Color pickers and palette generators
Recipe scalers and unit converters
Markdown previewers and note pads
Single-player browser games
Personal portfolio sites
Offline PWAs that sync on demand

When you genuinely do need a server, just ask

mk0r provisions a Neon Postgres database, a Resend email key, and a PostHog app id at session start, in parallel, before you have typed anything. The credentials sit in /app/.env. The agent is told to leave them alone unless your prompt requires them. The moment it does ("remember my data across browsers", "send me an email when someone fills the form", "track button clicks"), the agent picks up the appropriate env var and writes the smallest piece of server code that satisfies the request.

Until that prompt comes in, the database has no schema, the email key sends no mail, and the analytics token captures nothing. Your app stays frontend-only because nothing in your code reaches for those values.

0

Lines in the only infra file

0

Server frameworks in the scaffold

0

The only dev-time port mk0r needs

Want a frontend-only app shipped this weekend?

Hop on a 15 minute call and walk through what you want built. We'll keep the server count at zero unless you ask for one.

Frequently asked questions

What does "no backend" actually mean for an AI-built app?

The strict reading is: the running app has no server-side code that you wrote or that the builder generated for you. No Express, no Next.js API route, no Supabase or Convex calls, no per-user database. State lives in React useState, persistence (if any) lives in localStorage or IndexedDB, and the deployed artifact is a folder of static files served by any CDN. mk0r's pre-baked sandbox holds itself to that standard. The only "infrastructure" file in the scaffold at /app is src/_mk0rBridge.ts, and all 28 lines of it do is forward Vite HMR events to the preview parent window via window.parent.postMessage.

Why would I want an app with no backend in 2026?

Three reasons that come up over and over in weekend-project threads. First, friction: a frontend-only app has no signup, no auth, no "set your password" email, no rate limit, no migration. Second, cost: a static React bundle is free or near-free to host on Cloudflare Pages, GitHub Pages, Netlify, or an S3 bucket. Third, ownership: you can download the bundle, host it yourself, and your data stays on your own device. Most habit trackers, calculators, BMI tools, study cards, color pickers, and offline-first PWAs were never going to need a multi-user database in the first place.

Doesn't mk0r still provision a Postgres database for every session?

It eagerly provisions optional services in parallel at session start (Neon Postgres, Resend, PostHog, GitHub) and writes whatever was successfully created to /app/.env. But provisioning is not the same as use. The agent is told in /app/CLAUDE.md to "always check that the env var exists before using it" and to only use these services for behaviors that genuinely need them: cross-device persistence, transactional email, analytics, source control. If you ask for a habit tracker, the generated app reads and writes localStorage and the DATABASE_URL sits unused. Verify it yourself: the running preview makes zero network calls beyond Vite's dev-server HMR socket and any explicit fetch the agent wrote into your code.

How can I tell whether the app the AI just built actually has a backend?

Three quick checks. Open the network tab in the preview, refresh, interact with the app, and look for any fetch or XHR to a non-localhost URL: if there are none, you are frontend-only. Run grep -ri "fetch(\|axios\|supabase\|fetch " /app/src and grep for DATABASE_URL or RESEND_API_KEY usage: if nothing appears, no server is being called. Check package.json for server dependencies (express, fastify, next, hono, drizzle, pg, prisma, supabase-js): a clean package.json beyond react, react-dom, vite, tailwindcss is the green light.

What about competitors that say they handle the backend for you?

Lovable, Base44, Appy Pie, Glide, Zite all market themselves as backend-free for the user, which means "we set up Postgres or Firestore on your behalf and hide it." That is fine when your app needs auth, multi-user data, and role-based permissions. It is overkill, and lock-in, when you are building a Pomodoro timer for yourself. mk0r's behavior is closer to the bottom of that ladder by default: a habit tracker stays a habit tracker, a calculator stays a calculator, and the deployed artifact is a static React bundle you could host on a USB stick.

If I do need a backend later, how do I add one?

Just say so. "Make this remember my data across browsers" or "add login" flips the agent into reading /app/.env, finding DATABASE_URL or NEON_HOST, and writing the smallest piece of server-side code that satisfies the request. The Postgres database is already there waiting because mk0r provisioned it eagerly at session start; the agent just stops ignoring it. You can also keep the app frontend-only and replace localStorage with an exported JSON file the user uploads to a cloud drive, which is sometimes the right answer.

Is the published app really just static files?

When you press Publish, mk0r asks for a domain and ships an email notification to provision the mapping. What gets served is whatever the Vite dev server was rendering: React components, Tailwind CSS, optional fetched data. If your app never wrote a server route, the published version doesn't have one either. There is no auto-spun Lambda, no implicit edge function, no proxy that turns your frontend into a serverless backend behind your back. What you wrote is what runs.

Try mk0r for yourself. No account, no signup. The default app you get back will not have a backend.

Start Building
mk0r.AI app builder
© 2026 mk0r. All rights reserved.