Lovable for UK indie hackers: a 30-day teardown

There are now dozens of global Lovable reviews. None of them tells you what happens when a UK indie hacker spends 30 days trying to ship a real UK SaaS on it. This is that review. Built a VAT-compliant invoicing tool for UK sole traders over four weeks, paid in GBP, used Stripe UK, served a real cookie banner, and switched to Claude Code twice when Lovable hit limits.

The short version: Lovable is excellent for week 1 and the first half of week 2. It is solid but slower from there. The combined stack — Lovable for UI, Claude Code for business logic, Supabase underneath — is the thing that actually shipped.

Here's the diary.

The project

Fictional but grounded. A UK-specific invoicing tool for sole traders:

• GBP pricing with correct VAT handling (including the "VAT unregistered" flag for under the GBP 90,000 threshold).
• Stripe UK payment collection, not just Stripe.
• Date format DD/MM/YYYY throughout.
• HMRC-compatible CSV export.
• GDPR + PECR cookie banner.

The kind of SaaS that has a couple of hundred potential UK customers within reach if it actually works.

Week 1: Setup and first prototype

Tier chosen: Launch at GBP 40-ish per month. Free tier burns credits too fast for real building; Starter hits the limit on day three of iteration.

Day 1-2. Prompted Lovable to build the invoicing flow. Clean start screen, list of invoices, "create invoice" button. 15 minutes from first prompt to clickable prototype. Used around 35 credits.

Day 3. Supabase auth wired up. Lovable's Supabase integration is solid — it picked the right tables, set up row-level security policies reasonably, and created a working login page. Another 40 credits.

Day 4-5. The VAT piece. Here Lovable started to slow. Asking for "add UK VAT handling" produced a generic 20% VAT toggle. Getting it to do the real thing — reverse charges for B2B EU, "no VAT" for unregistered sellers, registration threshold awareness — took three further iterations and about 60 credits. The result worked but wasn't quite production.

Week 1 total: GBP 25 of credit burn. Three working screens. Roughly 60% of what I expected, mostly because VAT is genuinely a UK-regulatory wrinkle that none of the tool's training data covered cleanly.

Week 2: Stripe GB and webhooks

Day 8. Stripe UK integration, including GBP pricing and 3D Secure. Lovable's Stripe scaffolding is fine for USD. GBP is slightly more awkward: I needed to tell it explicitly to use GBP as the base currency and to set up a Stripe webhook to Supabase. That worked on the second try. About 50 credits.

Day 9-10. VAT invoice generation. This is where I hit the first real wall. I needed the invoice PDF to meet HMRC's requirements — sequential numbering, VAT registration number, reverse-charge language where applicable, correct GBP formatting. Lovable generated a PDF, but the layout kept breaking on mobile and the reverse-charge language was hallucinated. Switched to Claude Code for this piece: 45 minutes, clean output, precise HMRC compliance. Moved on.

Day 11-12. Webhook edge cases. When Stripe retries a payment, do we duplicate the invoice? Lovable suggested a deduplication pattern that was almost right but missed the idempotency-key handling. Claude Code, again, rewrote that layer cleanly in 20 minutes. Back to Lovable for the UI of the webhook log view.

Week 2 total: GBP 20 of Lovable credit, plus about 45 minutes of Claude Code work. Four screens, working end-to-end for a basic invoice flow.

Week 3: Supabase auth, ICO compliance and data model

Day 15. Second auth pass. Added magic-link login (UK SaaS customers tend to dislike passwords on small B2B products). Lovable did this in one prompt. 20 credits.

Day 16-17. ICO compliance. This is where a UK builder has to do work no US tool anticipates. Specifically:

• Cookie banner with reject-as-easy-as-accept.
• First-party analytics only (DUA Act 2025 exemption).
• Explicit "do not sell my data" pathway (even though we don't sell data, ICO expects the option).
• Data export and deletion endpoints for GDPR subject access requests.

Lovable installed a generic cookie consent library. It was not quite UK-compliant — default was opt-out rather than opt-in. I rewrote it by hand (vanilla JS + localStorage, about 60 lines) and kept Lovable managing the rest of the UI. This is a good illustration of the fundamental mental model: Lovable for app skeleton, Claude Code or hand-roll for anything with UK regulatory teeth.

Day 18-19. Data model extensions. Add clients, projects, recurring invoices. Lovable was strong here — it understood the domain model on the second prompt and suggested a sensible Supabase schema. 70 credits.

Week 3 total: GBP 25 of Lovable credit, plus about two hours of hand-rolled compliance work. Seven screens, roughly MVP shape.

Week 4: Polish, cookie banner, deploy

Day 22-23. UI polish. Lovable shines here. Ask for "make the invoice list more scannable, inspired by Linear" and it iterates in three prompts. 30 credits.

Day 24. Custom domain. Lovable deploys to *.lovable.app by default. Pointing invoices.madeup-domain.co.uk at the app was straightforward — DNS CNAME, one admin setting in Lovable. About 10 minutes, no credit cost.

Day 25-26. CSV export for HMRC self-assessment. Lovable built this in one prompt and failed on edge cases (negative amounts for credit notes, zero-rated VAT entries). Claude Code re-wrote the export function in 25 minutes with proper handling.

Day 28. Beta launch. GBP 5 flat price with Stripe UK. Announced on LinkedIn, r/UKAccountants and a small email list. Six signups in the first 48 hours.

Week 4 total: GBP 15 of Lovable credit, plus 25 minutes of Claude Code. Shipped.

Credit burn total

Week	Lovable credit (GBP)	Claude Code time	Notes
1	25	—	Foundation, auth, early VAT
2	20	45 min	Stripe GB, webhook edge cases
3	25	120 min	ICO compliance, data model
4	15	25 min	Polish, HMRC CSV, deploy
Total	85	~3.2 hours	—

GBP 85 of Lovable for a 30-day shipped UK SaaS is within the Launch tier budget. Running on Starter (GBP 16-ish) would have hit the credit cap on day 12. Scale (GBP 80-ish) is overkill for a single builder at this stage.

Where Claude Code would have been faster / slower

Claude Code would have been faster for:

• HMRC CSV export.
• Webhook idempotency.
• UK-specific regulatory logic (VAT nuances, reverse charges, cookie consent).
• Anything involving "three edge cases that are all subtly different".

Lovable was faster for:

• First-prototype screens from a verbal description.
• UI polish iterations ("make it look more like Linear").
• Supabase schema generation.
• Deploy + custom domain.

Claude Code would have been cheaper for the same total scope — probably around GBP 25-30 in API calls plus much more time at the keyboard. Lovable trades API cost for builder time.

UK-specific gotchas Lovable does not handle well

Worth calling out explicitly because none of the global reviews surface these:

1. VAT-inclusive pricing displays are not a default. UK consumers expect to see "£60 inc. VAT" not "£50 + VAT". You have to ask.
2. Date formats default to US (MM/DD). You have to tell Lovable DD/MM/YYYY. Even after telling it, about 10% of generated screens slip back. Worth a final pass before launch.
3. Companies House API is not scaffolded. For any UK B2B app that needs to verify customer businesses, you'll need to hand-roll or Claude-Code the integration.
4. ICO cookie requirements are not the default banner. Accept as easy as reject, block non-essential until consent, DUA Act 2025 exemption for first-party analytics — all need explicit prompts or hand-rolling.
5. HMRC MTD VAT submission is a proper integration and Lovable won't build it from a prompt. If your product needs it, plan Claude Code work.

None of these are blockers. They're just a reminder that the tool is built on global training data and UK regulatory context is a layer you have to add yourself.

Verdict table

Dimension	Score (out of 5)	Note
Time-to-prototype	5	Lovable is unbeatable here
Time-to-shipped-UK-SaaS	4	Needs Claude Code co-pilot for edges
UK regulatory fit	2.5	Global training data, no UK defaults
Credit cost discipline	3.5	Launch tier OK for 30 days; Starter is not
Stripe GB integration	4	Works, needs explicit GBP flag
Supabase auth	4.5	Clean and quick
ICO / PECR cookie compliance	1.5	Default banner is not UK-compliant
UI polish iteration speed	5	Instruction-following is excellent

Decision tree

Start on Lovable if you need to ship a prototype in under a week for a UK internal audience, want to see clickable UI from a verbal description, and are prepared to replace the compliance layer by hand.

Start on Claude Code if your product has UK-specific regulatory logic (HMRC MTD, FCA, ICO), needs complex backend logic out of the gate, or is a pure-API product with minimal UI.

Combine them (recommended for most UK SaaS) — Lovable for UI, Claude Code for backend business logic, Supabase underneath. That's what actually shipped this project in 30 days for GBP 85 of credit and 3.2 hours of Claude Code time.

Key takeaways

• Lovable is excellent for speed-to-first-prototype; Claude Code is better for depth and refactoring.
• Credit burn on Lovable for a real UK SaaS hits roughly GBP 40-80 over 30 days on the Launch tier.
• UK-specific concerns (VAT, ICO, DD/MM dates) need hand-wiring; Lovable does not know UK conventions by default.
• Stripe GB integration works cleanly; Companies House API and HMRC MTD need manual scaffolding.
• Best results come from Lovable for UI and Claude Code for backend business logic on the same project.

FAQs

Is Lovable better than Claude Code for UK indie hackers?

Not better — complementary. Lovable is faster to first prototype; Claude Code is faster to UK-compliant production. The best outcome is to use Lovable for UI and Claude Code for business logic, especially when UK regulatory context matters.

How much does Lovable actually cost in GBP for a 30-day build?

Around GBP 85 of credit on the Launch tier for a real shipped UK SaaS, based on this teardown. Running on the Starter tier (GBP 16-ish) would have hit the credit cap around day 12. Scale tier is overkill for solo builders at this stage.

Can I handle UK VAT properly in a Lovable-built app?

Yes, but not on the first prompt. Lovable's default VAT implementation is a generic 20% toggle. You need to iterate explicitly for UK nuances (unregistered sellers under the GBP 90,000 threshold, reverse charges for EU B2B, zero-rated items). Complex VAT logic is usually faster in Claude Code.

Is a Lovable-built app ICO-compliant out of the box?

No. The default cookie banner is not UK-compliant (reject is less prominent than accept, non-essential is not blocked until consent, first-party analytics exemption under DUA Act 2025 is not defaulted). You need to rewrite the banner layer by hand or with Claude Code.

Should I switch from Lovable to Claude Code mid-project?

Switch specific feature pieces, not the whole project. Lovable keeps working for UI and data-model scaffolding. Claude Code works better for webhook edge cases, HMRC CSV exports, ICO cookie banners, and any UK-regulatory business logic. Keeping both in the same project is the pragmatic pattern.

---

Get the latest free IdeaStack report each Thursday: ideastack.co. One deeply researched UK business idea, real keyword data, competitor analysis, builder prompts.