Why I Built Qanvas: The Story, the Trade-offs, and the Economics

By Cedric · Maker of Qanvas · Orbital Softworks (opens in new tab)

Earlier this year, I needed to put together several clean, fast marketing sites. Not just one quick prototype, but a handful of web properties that needed modern frontend standards, clean responsive typography, and zero architectural baggage.

Around the same time, I found myself helping friends navigate their own website setups. In every conversation, the same pattern kept showing up: visual builders that start out simple or cheap, but quickly turn into an ongoing tax. Capabilities you naturally need—custom domains, clean exports, extra pages—frequently carry add-on charges. When someone eventually wants to migrate or rebuild, the platform lock-in is often so deep that moving means throwing everything away and rebuilding from scratch.

I didn't set out to study the market or chase competitors. Over months of engineering on Qanvas, I only briefly looked at an external AI builder for the first time recently. My focus was much simpler: I wanted a focused, local tool that builds clean Next.js code without rent-seeking friction.

Why Unbounded AI Creates Frankenstein Code

When generative AI tools started appearing, the initial reaction was to let large language models write everything: prompt for an entire page, generate hundreds of lines of raw JSX, and drop it into a folder.

If you have tried to maintain code generated that way, you know how quickly it falls apart. Unconstrained models invent one-off components, mix styling paradigms, and assemble fragile "Frankenstein" codebases. They make confident promises in the preview that collapse the moment you try to modify a layout or wire up real routes.

In Qanvas, the AI does not have write access to raw component code. Instead, it operates inside a deterministic design system of schema-checked blocks:

• Every block, layout mode, and token change is validated against strict schemas before anything is staged. If an edit produces an invalid prop or an unsupported layout combination, Qanvas rejects it immediately.
• Typography, spacing bands, and color roles are bound to a verified palette. The model cannot invent arbitrary hex values or random layout rules on a whim.
• What you see on the canvas is a direct reflection of standard Next.js, React, and CSS. When you inspect the Code tab, you are reading the actual source tree—not a proprietary runtime format.

Deliberate Boundaries and the Pipeline

Many visual builders attempt to do everything at once: visual databases, authentication flows, backend logic, and complex state management.

Qanvas is intentionally constrained. It is built specifically for marketing sites, landing pages, and documentation portals. It does not attempt to be an authentication engine, an ORM, or an internal admin dashboard.

Because the product boundary is clear, the workflow functions as a transparent, auditable software pipeline:

1. Blueprint: Every project starts with living specifications (docs/PRD.md and docs/TDD.md) that capture your positioning, architecture, and constraints. Qanvas does not pretend to build complex full-stack web applications; if a project outgrows its visual marketing shell, your PRD and TDD provide clear context for human engineering teams.
2. Design: A live canvas where you can direct changes through conversational AI or fine-tune properties directly with the visual inspector.
3. Code: A read-only view of the TypeScript, React, and CSS source that updates as you design.
4. Export: A complete, standard Next.js project that you can download and run with npm run build. There are no vendor SDKs, no third-party analytics injected, and no proprietary hosting requirements. You deploy to Vercel, Cloudflare, Netlify, or your own server.

Why BYOK and Pay-Once Align Incentives

The prevailing model for AI tools is the centralized wrapper: the vendor charges a recurring monthly subscription, proxies prompts through their backend, and acts as an intermediary.

That architecture introduces trade-offs for both parties.

Qanvas runs locally on your machine. Your project files, design drafts, and API keys remain on your computer. When you work with the AI, prompts and relevant context are sent directly from your machine to your chosen AI provider (Google AI Studio, Anthropic, or OpenAI). We operate no intermediary server storing your drafts or inspecting your prompts.

Instead of bundling AI into an expensive recurring subscription, Qanvas uses Bring Your Own Key (BYOK). You connect your own API key and settle inference costs directly with your provider. Neither of us has to absorb, manage, or mark up inference costs.

This separation is what makes our commercial model straightforward:

• Community Edition is free with full features for a single active project, for personal, educational and evaluation use. There are no artificial watermarks, disabled components, or exported code restrictions.
• A Lifetime License unlocks unlimited active projects and workspace switching permanently.

No monthly subscriptions, no hosting lock-in, and full ownership of your code.

---

Getting Started

You can run Qanvas locally without creating an account or providing a credit card:

npx getqanvas --start

Qanvas opens at http://localhost:7140 in your browser. Configure your AI key in Settings and start building.

If you have questions about the architecture, feedback on the guardrails, or thoughts on the approach, write to me at support@getqanvas.com.