Lovable Review 2026

Lovable earns a shortlist when the deliverable is a working web application, not a snippet. Official docs describe a full-stack path: UI, Lovable Cloud (database, auth, storage, edge functions, realtime), connectors, native hosting with HTTPS, and two-way Git sync. Paid plans can download the codebase. That combination is the product. A chat window that only writes React is not.

The constraint that decides the buy is the credit pool. One balance now pays for build messages, Cloud hosting and backend, and AI gateway calls made by the deployed app. When that balance hits zero, building stops, in-app AI stops, and Cloud-backed services can pause shortly after. A credit shortfall is not only an authoring inconvenience. It can become a production availability incident.

How we evaluated this

This is a desk review with a buyer-risk lens, not a paid multi-week production benchmark. We checked the official homepage, pricing page, subscription-plan docs, credits-and-usage docs, Git sync docs, hosting and Cloud docs, security page, connector docs, MCP docs, changelog, and Trust Center URL on August 19, 2026. Recheck checkout before you sign, because Pro and Business credit selectors are volume-based. We did not buy a Business workspace, did not load Trust Center reports (the URL resolved but report content did not render), and did not independently audit generated-code quality on a production workload.

Cost model

The same credits that build the app can take the live app down

Most AI coding tools meter authoring. Lovable meters authoring and the hosted backend from one workspace balance. That is the original cost problem. Official credits and usage docs state that credits cover build usage, Cloud usage (database, network, storage, compute, realtime), and AI gateway usage inside the deployed app. Usage-specific grants (daily build credits, a monthly Cloud grant, a monthly AI grant) are spent first. After that, general credits pay for everything, including keeping the app up.

• Included credits are not a runtime SLA. Free, Pro, and Business each include 5 daily build credits and 20 Cloud credits plus 4 AI credits per month. Lovable labels the Cloud and AI grants as a temporary offering subject to change. Do not build a TCO model on those grants remaining free.
• Pro is cheaper per credit than Business for the same meter. Pro 100 credits is $25 per month ($0.25 per included credit). Business 100 credits is $50 per month ($0.50 per included credit). Pro top-ups are $15 per 50 credits ($0.30 each). Business top-ups are $30 per 50 credits ($0.60 each). You pay double on Business for SSO and governance, not for cheaper runtime.
• Zero balance pauses more than the chat. Docs say building stops, deployed-app AI features stop, and built-in backend services (database, storage, auth-dependent functions) pause shortly thereafter. Data stays, but you cannot access or export it until services run again. The published HTML shell can stay up while the app behind it is dead.
• Auto top-up is how a $25 plan becomes a variable bill. Defaults in docs: 100-credit top-up, 25-credit threshold, 400-credit monthly spend limit. Owners can raise that to no limit. A busy in-app chatbot can burn the 4-credit AI grant, then general credits, then auto top-up, while the team still thinks they bought a $25 authoring tool.
• Member limits do not cap runtime. Per-member monthly limits apply to build credits only. Run credits belong to the project. A quiet builder and a noisy live app can still drain the workspace.

Worked example on current public rates. A founder on Pro 100 credits ($25 monthly, or $250 per year) spends about 40 build credits in month one on auth, a dashboard, and Stripe. Illustrative Build-mode examples run from 0.50 credit for a style edit to about 2 credits for a landing page with images. After the 20-credit Cloud grant, modest traffic is cheap. Add a user-facing assistant. The AI grant is 4 credits. If that assistant burns 30 credits in a launch week, you have 30 credits left for building and hosting combined, then you are in top-up territory at $0.30 per credit on Pro, or $0.60 on Business. Governance is real. The meter is not more generous. Model three months as build + Cloud above the grant + in-app AI + the auto top-up ceiling you will actually set, then compare that to Replit or Cursor. Do not compare sticker prices.

Who Lovable fits best

Surfaces to verify

Lovable is a builder workspace, not a support inbox. Map each surface to a risk tier before you connect production data.

• Web, desktop, and mobile builder. Natural-language Plan mode (1 credit per message, no code changes) and Build mode (variable credits).
• Lovable Cloud. Hosted backend: database, auth, storage, edge functions, realtime. Instance size is selectable on paid plans. Pause Cloud on idle projects or it keeps drawing Run credits.
• Hosting and domains. Native publish with HTTPS. Custom domains on paid plans. Apps created from 13 May 2026 use server-side rendering per hosting docs. Older React/Vite projects may migrate to TanStack Start.
• GitHub and GitLab. Two-way sync. One repo per project. One synced branch flows back. GitHub repository renames are followed. GitLab renames still break sync. Reconnect creates a new repository. Self-hosted GitHub Enterprise Server is an Enterprise feature.
• Connectors. Four patterns: app + chat (shared), chat-only MCP context, app-user OAuth, and custom API or MCP. Catalog presence is not equal depth. Gateway connectors encrypt tokens and cap at 1,000 requests per minute per connector per project. Non-gateway connectors can expose secrets in the project.
• MCP server. External clients can create projects, message the agent, inspect code, and deploy. Docs list OAuth for ChatGPT, Claude, Cursor, and VS Code. Changelog has mentioned a Codex plugin while the OAuth list does not name Codex. Confirm in writing if Codex is a requirement.
• In-app AI gateway. Separate from the builder agent. Draws the 4-credit monthly AI grant first, then general credits, at provider-model rates.

Agent workflow and publishing guardrails

The loop is: describe the app, Plan mode to think, Build mode to change code, preview, publish, then iterate. Lovable processes one Build task at a time and queues further prompts. Stopped Build requests still charge for work already done. Editing, approval, and publishing are separate permissions, enforced server-side. Public-by-link is the default. Business adds internal publish. Enterprise restricts who can publish and invite. A basic security scan runs on every publish (about 10-15 seconds). Deep scans take about three minutes. Treat those scans as a seatbelt, not a crash test.

Git is the exit, with a catch. You cannot import the repo you already have. You generate in Lovable, sync out, then optionally work in Cursor on the synced branch. Database data is not in Git, only migration files. Plan a Cloud data export before you assume you can walk away cleanly.

• Start in Plan mode for architecture and auth decisions so you do not spend variable Build credits on a bad data model.
• Set per-member build-credit limits before you invite a whole company to one workspace.
• Turn on credit check-ins (default 20 credits) so a single runaway Build message cannot silently consume the month.
• Pause Cloud on abandoned prototypes. Docs also auto-pause after inactivity, but scheduled jobs still cost money until you intervene.
• Keep auto top-up on a monthly ceiling you would defend to finance, not on "No limit."

Pricing checked August 19, 2026

Lovable pricing: credit workspaces, not seats

Public packaging is Free, Pro, Business, and Enterprise. Pro and Business scale from 100 to 10,000 monthly credits. Annual billing is the monthly amount times 12 at the discounted rate shown in official subscription docs (for example Pro 100 credits is $250 per year, displayed as $21 per month). Credits are not equal in value across plans. The pricing page FAQ states that explicitly.

Sources: lovable.dev/pricing and subscription plan docs, checked August 19, 2026. Confirm the live credit selector, taxes, regional daily-credit caps, and Enterprise volume rates at checkout. Monthly-plan credits expire two months from issue. Annual-plan credits expire one month after the annual period ends. Top-up credits last 12 months. Unused monthly plan credits roll over while the subscription stays active.

If you only need more credits, stay on Pro and raise the selector (official docs list Pro 10,000 credits at $2,250 per month versus Business 10,000 at $4,300). Move to Business for SSO and internal publish, not for cheaper Run credits. Lovable says Run and AI unit costs are the same on Pro and Business. Because Business credits cost more, the usage UI will show fewer credits consumed for the same Cloud work after a Pro-to-Business switch.

AI capability and code generation

Lovable positions itself as an AI software engineer for the web. Plan mode is a 1-credit conversation that does not edit code. Build mode implements changes and bills by work done. That split is useful. Teams that skip Plan mode will burn credits rediscovering architecture inside Build mode.

Quality is the buyer-owned risk. Generated UI, auth, RLS, and connector calls still need review. Official scanning looks for misconfiguration patterns. It will not catch a permission model you described poorly. Treat "production-grade" on the homepage as positioning. If the app's job is a chatbot, you are also buying a hosted LLM wrapper. Price that path against ChatGPT instead of assuming the 4-credit AI grant will cover it.

Feature areas to verify in a pilot

Do not accept a homepage demo that only restyles a landing page. Require the surfaces your workload will use.

• Plan mode then Build mode on one real internal tool, with credit cost recorded per message.
• Auth, RLS, custom-domain publish, and a republish after a Git commit from outside Lovable.
• GitHub or GitLab two-way sync, then a reconnect test (expect a new repo).
• One gateway connector and one non-gateway connector, including secret visibility.
• In-app AI against the 4-credit grant, plus a zero-credit drill on staging.
• SSO on Business if that is why you would leave Pro, and Cloud data export, not only Git.

Analytics and operating visibility

Credit operations live under Settings, Plans and credit usage. Usage details split Build credits from Run credits (Cloud plus AI gateway). You can filter by time, project, and person for build usage. The Cloud tab inside a project shows the same Run breakdown for that app: database, network, storage, compute, realtime.

That is enough to run a pilot if someone actually opens it. It is not a finance export by default. Ask whether you can attribute Run credits to a cost center, and whether alerts fire before auto top-up. Member profiles show 7-day and 30-day credit usage. Confirm billing alerts reach the person who owns the credit ceiling, not only the person who likes building.

Security, data handling, and compliance

The security page states SOC 2 and GDPR support, secrets encrypted at rest, logical workspace isolation, WAF on Cloud, and SAML/OIDC with Okta, Azure AD, and Google. SCIM is Enterprise. Business includes SSO and the Security Center. Enterprise adds audit logs, scheduled deep scans, and GitHub Enterprise options. Cloud residency is EU, US, and Australia.

Training is the detail buyers miss. Business and Enterprise: prompts, code, and workspace data are not used to train Lovable models. Free and Pro: opt out in Account Settings, Privacy. Request the DPA, subprocessors, SOC 2 Type II period and exclusions, and ISO 27001 scope. The Trust Center URL resolved in this session but report content did not render. Badges are not a substitute for the PDF.

• Confirm whether your workspace is already on the unified credit model. Lovable says the one-balance rollout is gradual; some workspaces may still show older Cloud/AI dollar balances.
• Gateway connectors: encrypted tokens, live retrieval, delete-to-revoke, 1,000 RPM per connector per project. Non-gateway: different auth, possible secret visibility to the agent.
• Publishing events are logged with user attribution on the security page. Do not assume audit-log export exists below Enterprise.
• Generated-app pen tests are a separate Lovable offering for founders. They do not certify the platform.

What questions should you ask before buying Lovable?

• What did a comparable app consume in build, Cloud, and runtime AI credits over 30 and 90 days?
• What exact user-facing failure happens when credits hit zero, including auth, storage, and in-app AI?
• Who can set auto top-up amount, threshold, and monthly ceiling?
• Do we need Business SSO and internal publishing, or is Pro plus a raised credit selector enough?
• Which connectors are gateway-based, and do any secrets sit in the project?
• Can we keep the app running if we export code and Cloud data and leave Lovable hosting?
• Will you provide current SOC 2 Type II and ISO reports, DPA, and subprocessors under NDA?
• Is Free/Pro training opt-out on, and is Git sync's "no import, new repo on reconnect" model acceptable?

What red flags should you watch for with Lovable?

• The demo never shows a live app after the credit balance is emptied.
• Sales treats Cloud and AI grants as permanent included capacity.
• Auto top-up is enabled with no monthly ceiling during a "just try it" rollout.
• You need to modernize an existing repository and the vendor waves at Git sync anyway.
• Publishing stays public-by-link while the app holds customer data, and nobody has Business visitor controls.
• Security review stops at the badge and never requests the SOC report or DPA.
• Non-gateway connectors hold production secrets the agent can see.
• Nobody is assigned to review RLS, auth, and generated dependency updates before each publish.

What are the best alternatives to Lovable?

Pick by the job. A prompt-to-app builder is not an IDE agent, and a general assistant is not a host.

• ReplitChoose Replit when you want a collaborative browser workspace, agent-driven scaffolding, and a broader coding environment, and you will compare credit burn on that meter instead of Lovable Cloud.
• CursorChoose Cursor when the repository already exists and the job is professional editing in a local or project codebase rather than generating a new hosted app.
• GitHub CopilotChoose Copilot when developers already live in GitHub and the editor, and you do not need Lovable's hosted backend or prompt-to-publish loop.
• ChatGPTChoose ChatGPT when you need code, specs, and light agent work in a general assistant, and you will host and deploy on your own stack.
• ClaudeChoose Claude when long-context reasoning, coding chat, and a bounded assistant matter more than a hosted Cloud backend and credit-metered runtime.

Workflow test

What Lovable needs to prove in a real workflow

A pretty generated landing page is not a buy decision. Run this four-step test on a non-sensitive internal tool before you put customers on a custom domain.

1. Build one representative app.Include auth, one integration, and one data model that must survive a refresh. Record credits per Plan and Build message, and whether check-ins fired.
2. Run it with traffic and AI on.Hit the live URL, exercise Cloud paths, and turn on any in-app AI. Compare Run credits to the 20 Cloud and 4 AI grants.
3. Force a zero-credit event on staging.Confirm building stops, AI stops, and Cloud pause/restore behavior, including whether you can export data while paused (docs say you cannot until services run again).
4. Leave.Sync to GitHub or GitLab, download the codebase, export Cloud data, disconnect, and confirm reconnect creates a new repo. Decide whether that exit is acceptable.

• Replit reviewCompare another prompt-to-running-app path with a different credit and hosting model.
• Cursor reviewUse this when the alternative is an AI-first editor on a repo you already own.
• GitHub Copilot reviewUse this for in-editor coding assistance without a hosted app builder.
• How to choose an AI agent platformDecision criteria that apply beyond a single vendor demo.
• Tools directoryScan adjacent builders, IDEs, and assistants on the same scorecard language.
• AI agent buyer scorecardTurn the four-step workflow test into a written go or no-go.

Official sources to verify

Official product pageSource snapshot 2026-08-19 - lovable.devPositioning, hosted-app claims, and product surfaces checked against the vendor homepage. Official pricing pageSource snapshot 2026-08-19 - lovable.dev/pricingPlan FAQ, credit definition, Free grants, and Enterprise packaging checked August 19, 2026. Credit selectors are documented in official subscription docs.

Also verify: Credits and usage, Subscription plans, Git sync, Security, Changelog, and Trust Center. Screenshots are editorial captures; confirm live pages before purchase.

Claim and source ledger

Should you choose Lovable?

Lovable is a prompt-to-hosted web app platform with editable code, Lovable Cloud, connectors, and Git-backed export. Public pricing as of August 19, 2026 starts at $25 per month for Pro with 100 credits ($21 per month billed annually) and $50 per month for Business with the same 100 credits ($42 per month billed annually). Enterprise is a platform fee plus volume pricing. Unlimited members are included. The meter is credits, and those credits also run the live backend.

Choose Lovable when you will generate a new web app, host it there at least through launch, and keep a Git copy you can take elsewhere. Look elsewhere when the repo already exists, when a paused Cloud backend is an outage you cannot accept, or when procurement needs inspectable attestations before a proof of concept. Set a credit ceiling, test zero-balance behavior, and assign a human to review auth and RLS before you publish.