# How we built an AI website builder you can actually own > The AI website builder market settled into one shape fast: type a sentence, get a website, pay every month forever. Lovable reached $200M ARR in under a year doing exactly that. Durable, Framer, Wix's ADI, and Vercel's v0 all run the same loop. The product is genuinely good. Source: https://saascode.ai/inside/how-we-built-an-ai-website-builder-you-can-own · Published: 2026-08-29 · Section: builds · Product: Adorable (https://saascode.ai/products/adorable) --- The AI website builder market settled into one shape fast: type a sentence, get a website, pay every month forever. Lovable reached $200M ARR in under a year doing exactly that. Durable, Framer, Wix's ADI, and Vercel's v0 all run the same loop. The product is genuinely good. The arrangement — you rent the engine and never own it — is the part we wanted to take apart. Adorable is what came out of that: a complete AI website builder that ships as code a buyer owns and runs as their own multi-tenant SaaS. This is the log of how it got built, what we decided, and what fought back. ## Starting from the category, not a blank page The fastest way to build something hard correctly is to be honest about what the category has already worked out. In the abstract, AI website generation is a well-understood loop: classify what the user is asking for, generate structured HTML against a remembered design system, let them refine it, keep the output portable. The engineering is demanding, but the shape is known. What the category has *not* worked out is ownership — every product that does this well hands you a runtime you rent and never hold. So the real work was never reinventing AI generation. It was building that well-understood capability as a **business the buyer owns**: a multi-tenant SaaS where an operator signs up many customers — each with their own projects, billing, and limits — on a stack they can run themselves. Next.js, TypeScript, Supabase with row-level security, OpenRouter for the model layer, Stripe for billing. Original code, an ownable stack, and the one thing the incumbents won't sell you — the platform itself. ## Reading the market by its complaints The clearest product spec a category gives you is the list of things its users are angry about. The incumbents each leave a specific gap: - **Lovable** is a capable hosted platform — full-stack app generation, visual edits, version history, backend and custom domains *(docs.lovable.dev, checked 2026-08-30)* — but it stays rented and credit-metered: users report the AI rewriting working code while fixing something unrelated, and the dominant complaint is credit depletion on edits nobody asked for. - **Framer** locks the output inside its platform — no code export. The site is never fully yours. - **v0** has grown past components into full-stack app scaffolding inside the Vercel ecosystem *(v0.app docs, checked 2026-08-30)* — but it is a metered tool that builds apps *for you*; it is not a website-builder platform you can brand, operate and charge your own customers on. - **Wix's** AI has the largest small-business base and the reputation to match — slow pages, low review scores. Read together, those complaints describe one missing product: an AI builder that gives **precise control over what the AI touches**, produces **portable output the user owns**, and ships as **code the operator owns** rather than a runtime they rent. That became the design brief. ## The decisions that shaped it **Two models, not one.** Routing every message through a single large model is slow and expensive, and it makes intent ambiguous. Adorable splits the pipeline: a fast, cheap intent model classifies each request into one of a handful of actions — create a site, edit a page, change the design, edit a section, inline-edit a code block — before the capable worker model does the actual generation. The classifier is cheap enough to run on every keystroke-level interaction; the worker is reserved for work that earns its cost. Both are configurable through OpenRouter, so the operator picks the price-performance point rather than inheriting ours. **Three editing modes, because one is the actual bug.** The chat-box-only design is why incumbents burn credits: when the only way to say "move this 4 pixels" is a paragraph of English, the model guesses, and guessing is where working code gets overwritten. Adorable ships three surfaces over the same project. Chat handles structural changes. A visual editor lets a user click an element and adjust typography, spacing, and color directly — no model call, no guessing. A Monaco code editor with `Cmd+K` inline AI rewrites exactly the selection you highlight, nothing else. A restaurant owner lives in chat; a designer in the visual editor; a developer in code — same project, same tool. **Design intelligence as persistent state.** A model with no memory of its own past decisions produces a different-looking page every time. Adorable stores a per-project design profile — exact HSL values, font families with weights and tracking, spacing rhythm, radius personality, shadow rules, image direction — and injects it into every request. Page six matches page one without anyone re-specifying the brand, and a site revisited a month later still generates consistently. **Site memory, for the same reason at the content layer.** Business name, hours, services, differentiators — stored once per project and carried into every generation, so the user never repeats themselves and the AI never invents facts it was already told. **Snapshots on every action.** Generation is probabilistic; the safety net has to be deterministic. Every AI action and every edit writes a snapshot, so any state is restorable and any two are comparable. A user can take the headline from one version and the layout from another and lose nothing in between. **Stream the work, render as it lands.** Generation runs over server-sent events. File operations are parsed out of the stream in real time and the preview updates progressively, so the user watches the site appear rather than staring at a spinner for thirty seconds. **Portable output by construction.** The preview renders through the Tailwind Play CDN for instant feedback; export compiles Tailwind server-side so only the classes actually used ship. The result is plain HTML, Tailwind, and vanilla JavaScript — no React runtime, no build step, a five-page site under a second on any static host. Portability isn't a feature bolted on at the end; it's the output format. ## What fought back A build log that only lists wins is marketing. The honest parts: **Vercel's function ceiling versus full-site generation.** Generating a complete multi-page site can take longer than a minute, and serverless functions cap out — Vercel's Hobby tier at sixty seconds. The generation route is set to a 120-second budget, which means deployment-target choices matter, and long generations need a recovery path. We added bounded continuation: if a generation truncates, up to two non-streaming follow-up calls finish the job. It works, and it costs extra tokens — a real tradeoff documented rather than hidden. **Snapshots are cheap until they aren't.** Writing a snapshot on *every* AI action means heavy editing sessions accumulate a lot of them. The safety net is worth it; the deduplication to keep it lean is on the list. **The studio got rebuilt.** The first pass at the editing workspace — the panels, the preview bridge, the code editor wiring — didn't hold up, and the studio components were rebuilt rather than patched. The original build carried dozens of post-deploy fixes before it stabilized. That's the real shape of building a bidirectional `postMessage` editor with a live iframe: the architecture is simple to describe and unforgiving to get exactly right. **A rename leaves residue.** The project was called PageForge before it was Adorable, and renames are never fully clean the first time — a few internal references and a published-site script still carry the old name. Cosmetic, tracked, and a useful reminder that "rename the product" is a migration, not a find-and-replace. ## What shipped A multi-tenant AI website builder: AI generation with streaming, three editing modes, persistent design intelligence and site memory, versioned snapshots, subdomain publishing and ZIP export, an asset manager, a full admin panel with an editable AI-prompt layer and per-action model configuration, billing, internationalization, and rate limiting — a complete multi-tenant build, not a skeleton. It runs on a stack the operator owns, with the model layer abstracted so the per-generation cost is theirs to control. The thesis underneath all of it: an AI website builder doesn't have to be a runtime you rent. The hard parts — intent routing, design persistence, portable export, a forgiving editor — factor into code that ships. Once they do, the monthly-subscription shape that defines the category has nowhere left to attach. ## See it [See Adorable →](https://adorable.saascode.ai) ## Related reading - [Adorable vs Lovable — and vs building it yourself](https://saascode.ai/inside/adorable-vs-lovable-and-vs-building-it-yourself.md) - [Best AI website builder source code in 2026 (own it, don't rent it)](https://saascode.ai/inside/best-ai-website-builder-source-code-2026.md)