Framer is great. Lovable is impressive. I didn't use either. This site was built from scratch — entirely by Claude — and not because I'm a masochist or have a thing to prove. I did it because the hosted builders cost more than they look, own more of your stack than they admit, and stop exactly where the interesting work begins: the admin backend.
To be clear: I didn't hand-write the code. Claude did. Every line. My job was the requirements, the architecture calls, and the taste. That's the part people miss in the "AI website builder" conversation — you can have an AI write the whole thing and end up with a codebase you fully own, on infrastructure you control, with an admin that does whatever you want. Those aren't opposing choices.
Here's what got built, what I chose, and why the trade kept tilting away from the hosted tools the longer I looked at it.
The shortlist I rejected
I gave the obvious options a fair shake before pointing Claude at an empty repo.
- Framer — beautiful output, excellent CMS for marketing sites. But the moment you want non-trivial server logic, scheduled jobs, a custom admin, or to plug in your own auth, you're working around it rather than with it. And the pricing scales per site, per seat, per feature.
- Lovable / v0 / Bolt — fine for spinning up a prototype. The generated code is yours, technically, but the workflow assumes you keep prompting your way forward inside their environment. The minute you want to refactor like an engineer — or just open the project in your own editor with your own agent — the magic gets in the way.
- Webflow — same shape of problem as Framer, older interface, similar lock-in.
- WordPress — still a perfectly good answer for a content site. I didn't want the plugin surface area or the PHP hosting footprint.
None of these are bad tools. They're just optimised for a different builder than me — someone who wants a site, not a system.
What I actually wanted
Three things, in order:
- A real admin backend. Not "edit this text field in a sidebar." I wanted a place to draft posts, manage drafts vs published, attach images, organise topic clusters, and run AI-assisted authoring flows against my own content. That's an app, not a page builder.
- Ownership. The code, the database, the content, the deploy pipeline. If a vendor pivots, raises prices, or sunsets a feature, I shouldn't have to migrate.
- Lower cost at steady state. Hosted builders feel cheap until you add a second site, a team seat, or a CMS tier. My all-in monthly is in single-digit dollars.
Once I wrote that list down, the decision basically made itself.
The stack
Nothing exotic. Boring is the point — and boring is also what coding agents are best at.
- Next.js (App Router) on the frontend and for API routes. Server components keep the public pages fast and mostly static.
- TypeScript everywhere. Non-negotiable for anything I plan to maintain — and it gives the agent a tighter feedback loop.
- Postgres as the database — managed, but portable. The schema is mine.
- Tailwind for styling. The lowercase site chrome you see is just CSS; the content is written in proper case and rendered through
text-transform. - Vercel for hosting. Could move to Fly or Railway in an afternoon if the bill ever got annoying.
- A custom admin at
/admin, behind auth, with a proper editor, draft/publish states, image uploads, and hooks for AI-assisted drafting.
That last bullet is the whole reason I'm not on Framer.
The admin backend is the actual product
Most "website builders" treat the admin as an afterthought — a settings panel bolted onto a design tool. For a blog that's going to be the long-running home for writing, tools, and experiments, the admin is the thing. The public site is a read-only projection of it.
What I wanted my admin to do, that hosted tools won't:
- Draft posts with an AI assistant that knows my voice rules and existing topic clusters.
- Attach and reuse images without round-tripping through a separate asset manager.
- Auto-extract metadata (cluster, tags, reading time) on save.
- Let me schedule, unpublish, and revise without fighting a CMS abstraction.
- Eventually: ingest from other sources (notes, transcripts) and propose drafts.
Every one of those is a short, well-scoped task when you own the stack — exactly the shape of work a coding agent does well. On a hosted builder, half of them are impossible and the other half cost a plan upgrade.
The cost math
Rough monthly, steady state:
- Hosting: $0–20 (Vercel hobby works fine until it doesn't)
- Postgres: $0–10 (Neon / Supabase free tier covers a blog comfortably)
- Domain: ~$1/mo amortised
- Object storage for images: pennies
Call it under $20/month, with headroom for real traffic. Compare to Framer or Webflow with a CMS tier and a custom domain — you're at $25–40/month per site before you've added a teammate, and you don't own the backend.
The bigger cost saving isn't the line item. It's that I can run n sites on the same infrastructure for marginal cost. The admin, the components, the deploy pipeline — all reusable.
What it cost me instead
Honest accounting: Claude built the public site in an afternoon and the admin over a few evenings. My time went into deciding the stack, reviewing diffs, catching the occasional bad architectural turn, and writing the prompts that encoded what "good" looked like. If you're starting cold without a clear picture of the stack, budget a week — most of which is decisions, not typing.
The ongoing cost is maintenance — dependency bumps, the occasional Next.js migration, keeping an eye on the database. Most of that work also goes to the agent. In exchange I get to ship features on a Tuesday night without waiting for a vendor roadmap.
When you should use Framer or Lovable anyway
I'm not anti-hosted. Use them when:
- You need a marketing site live this week and you don't want to think about a stack.
- The site is genuinely read-only — no custom workflows, no admin ambitions.
- You're validating an idea and the site will be thrown away in three months.
Use what I did when:
- The admin is going to grow into a tool, not stay a form.
- You plan to run multiple properties off one codebase.
- You want AI workflows wired into your own data, not a vendor's plugin store.
The takeaway
The interesting question in 2025 isn't "should I use a website builder or write it myself." It's "which AI do I let drive, and how much of the stack does it hand back to me when it's done." Lovable hands you a project locked to its workflow. Claude in your own repo hands you a normal Next.js app you can run, fork, and extend forever. Same amount of typing on your end. Wildly different amount of ownership.
Hosted builders sell you the easy 80% and quietly own the hard 20%. If the hard 20% is where your project actually lives — and for anything with a real admin, it is — have an agent build it for you in a repo you control. The stack is boring, the cost is lower, and you stop renting the part of your product that matters most.