Lovable
The fastest way for non-coders to build a real, full-stack web app from a text prompt
Non-technical founders who need a working SaaS MVP without hiring developers
Complex data workflows, tight third-party API integrations, or production-critical apps
Lovable in context: product setup, workflows, and operations
Lovable is the tool that finally makes the “I’ll just build it myself” instinct viable for non-technical founders. Not viable in a “you could hack something together” way, but viable in a “you could charge customers for this” way. That’s a genuine shift, and it’s worth being specific about why.
New in November 2026: Automations, usage-spike alerts, and invitations you have to accept
Lovable’s changelog for November 10-12 has one feature worth your attention and several small fixes to long-standing annoyances.
The feature is Automations (November 11). You ask Lovable in Chats to repeat a task on a schedule: check your published sites every morning, summarize signups every Monday, list the oldest backlog items on Friday. Results are posted back in that chat, and a run with nothing new to report stays quiet. Automations are on Free, Pro and Business, and the docs set per-person limits: 3 automations on Free running at most once a day, 10 on Pro running as often as hourly, and 25 on Business running as often as every 15 minutes.
Two things to know before you set up a dozen of them:
- Every run costs something. Each run is billed as chat usage. It draws on your daily chat allowance first, then daily build credits, then your general credits, and if a run sends build work to a project, that work is charged as normal build usage. Lovable doesn’t publish a per-run figure. An hourly automation is roughly 720 runs a month, so start with daily and watch the usage page for a week.
- Automations can act, not just report. They can change projects and send messages through your connected tools. Actions like those pause for your approval by default, and unanswered requests expire after 7 days. There is an “Always allow” option. Be slow to click it.
Lovable pauses an automation after three failed runs in a row, or when you run out of credits. Don’t confuse this with Jobs, which is the separate feature for scheduled work inside the app you built.
The smaller changes:
- Usage-spike alerts (November 12). On paid plans, workspace owners and admins get an email and in-app notice when daily run usage (hosting, database and the AI features inside your live app) jumps sharply against the previous seven days. It warns you; it doesn’t stop anything. Pair it with the spending caps from October.
- Invitations are no longer auto-accepted (November 11). You now accept each workspace or project invite yourself, and the auto-accept setting is gone. This is a sensible security default.
- Credit renewal date (November 10). Pro and Business workspaces now show when monthly credits renew, right on the credit bar. The misleading “AI edits count” in project settings has been removed in favor of actual credit spend.
- Personal instructions and skills (November 10). You can set your own rules and playbooks per workspace that teammates never see.
New in October 2026: Organizations, hooks that can block actions, and Supabase from chat
Lovable’s changelog for October 19-27 is the most enterprise-flavored stretch yet. Enterprises can group several workspaces into one organization with a single SSO setup and automatic member provisioning (it’s arranged through your account team, not a self-serve switch). On October 27, Business and Enterprise admins got Events & Hooks: Events notify your own HTTPS endpoint when a project is created, published, transferred or deleted, and Hooks let that endpoint approve or block the action first, for example screening chat messages for sensitive data. That is a real governance control, and it matters more to a company rolling Lovable out than to a solo founder.
Founder-relevant items: you can now ask Lovable to create a Supabase project from chat, picking the organization and region, which helps if you want your own database instead of the built-in backend. The region can’t be changed afterward and Supabase bills you directly. New connectors include Cube (read-only access to your team’s agreed-upon metrics), n8n, LlamaParse and Scrive (e-signatures and national eID). Dictation now transcribes as you speak, and the sidebar was reorganized (Pinned, Projects, Recent chats), with “Knowledge” renamed “Instructions”.
One thing to check: Gemini 2.5 models were retired for in-app AI features on October 20. Requests are rerouted to Gemini 3.8 Flash or 3.1 Flash Lite, so your app keeps working, but cost and output may shift. If your app’s AI behaves differently this week, that’s why.
Verdict impact: none on the rating.
New in October 2026: Growth tools, “Sign in with Lovable”, and audit log exports
Lovable’s changelog for October 14-15 moves the product a step past “build the app” toward “get people to use it.” The headline is a set of Growth tools: you tell Lovable a goal, such as getting your first signups, and it recommends next steps for search visibility, landing pages and community outreach. It can also set up Google and Meta ads and generate the creative. Lovable adds no fee for this, but the ad platforms bill you for whatever you run, so set a daily cap before you let anything spend. I’d treat the recommendations as a decent checklist for a first-time founder, not a marketing strategy.
The other change with real consequences is Sign in with Lovable. Apps built on Lovable Cloud now get it on their login pages by default, and sign-ins use no credits. It also works on any website via a script tag or standard OpenID Connect, once a workspace admin registers an OAuth client. That’s convenient for a prototype, but it ties your users’ identity to Lovable’s accounts, so think twice before making it the only way into a product you plan to own long term.
For teams: Enterprise admins can schedule audit log exports to S3, Google Cloud Storage, Azure Blob Storage, Splunk or Azure Log Analytics, which gets around the 13-week retention limit. Business and Enterprise admins can also let people use the Lovable MCP server in Claude with company SSO (Claude needs a Team or Enterprise plan). Smaller items: GPT-6.1 Sol is now available for your app’s AI features, you can ask Lovable in chat what is driving your credit usage, deleted projects can be restored for 60 days, and there is a Bing Webmaster Tools connector.
Verdict impact: none on the rating.
New in October 2026: Browser agents can drive your app, and a premium Gemini model
Lovable’s changelog for October 12-13 has one item worth a founder’s attention. With agent integrations switched on, your published app can now expose WebMCP tools, which let an AI agent running in a visitor’s browser act on the open page, such as marking a task done. Lovable starts with read-only and easily reversed actions, and only adds delete, pay, send, publish or share tools if you ask. That default is the right one. If you do turn on the risky ones, treat them like any other permission you hand out.
Also new: Gemini 4 Argon is available for your app’s own AI features, accepting text, image, audio and video, at a premium price, so check the cost before wiring it into something users hit often. You can now approve every tool from a connector in one click (including tools added later), which is convenient and a bit loose, so use it only for connectors you trust. Lovable Cloud also clarified that it supports a fixed list of Postgres extensions (pg_cron, pg_net, vector, postgis and a few others) and refuses the rest. Smaller additions: image editing in Files, a Loops email connector, and a by-coverage view showing how much usage your free allowance covered.
Verdict impact: none on the rating.
New in October 2026: Invite-only publishing, cross-chat work, and nine new connectors
Lovable’s changelog for October 8-9 is mostly about sharing and plumbing. The one most founders will feel: Free and Pro users can now publish an app to a specific invited audience instead of the whole workspace, which makes it far easier to put a prototype in front of ten customers without making it public. Enterprise workspaces can also publish every project under one custom domain.
On the build side, you can now point one chat at another: reference a different chat, or have Lovable send it a message or start a new chat with a task. It’s an early step toward multi-project work, and worth trying if you keep a separate chat per feature. A new Generate button also creates strong random values for secrets that two places need, such as a webhook signing secret, which removes a small but common way non-coders get security wrong.
Nine connectors landed (Zendesk, Neon, MotherDuck, Oracle Autonomous AI Database, IBM Db2, Qlik Cloud, Omni, Metabase, GoodData), plus a Loom connector that lets Lovable read a video’s transcript and comments while it builds. Admins on Free, Pro and Business also get a warning when credits are likely to run out before the monthly refill.
One behavior change to know: Lovable no longer shows three design directions before building a visually open-ended prompt. It asks design questions instead. That’s less flashy and, in my view, a better default.
Verdict impact: none on the rating.
New in October 2026: Spending caps, database load warnings, and a Git “undo”
Lovable’s changelog for October 5-7 is unglamorous, and that’s the point: it’s the guardrail work that matters once real money and real users are involved. Workspace admins can now set usage limits and get alerts as credits burn down, so a runaway agent session is less likely to produce a surprise bill. If you’ve been nervous about handing a team access, this is the feature to look at.
Two Cloud database changes are worth knowing. Lovable now warns you when your database is under high load and offers a “Resolve” button, and every database change is recorded as a Drizzle migration file. The second one is quietly significant: a migration history means you (or a developer you hire later) can see how your data model changed, instead of inheriting a black box. Also new: you can restore your Lovable work after a Git push overwrites it, which fixes one of the more painful ways to lose a day.
Smaller items include new Klaviyo, beehiiv and Ramp connectors, and Gemini 3.6 and 3.7 Flash being deprecated for in-app AI features (they stop working November 19, 2026 and January 28, 2027). If your app calls those models, plan a swap.
Verdict impact: none on the rating, but the case for “Lovable is growing up” gets a little stronger.
New in September 2026: Annualized revenue crosses $600M, two-thirds of the Fortune 500 now use it
Confirmed by TechCrunch on September 24: Lovable’s annualized revenue has crossed $600 million, up from $500 million in June. That’s the number the company was “tracking toward” back in its August Series C announcement, and it landed. Two-thirds of Fortune 500 companies now use the platform in some capacity, with Microsoft, NVIDIA, and Deutsche Telekom named as enterprise customers. Apps built on Lovable now draw close to a billion monthly views, and the platform is generating roughly one million new projects every week.
Co-founder Fabian Hedin’s framing is worth repeating because it’s the clearest statement yet of what Lovable thinks it’s selling: “The difference is that Lovable does not output code. The output is a product, and increasingly so, a business.” That’s a claim about positioning against Cursor, Bolt, and other code-first tools as much as it’s a revenue update — Lovable is betting its moat is the whole business layer (hosting, domains, payments, trust centers), not just the code generation.
For you, this changes nothing about the product today. It’s a signal, not a feature. But given how much of this review’s caution is about platform risk and whether to build something real on top of Lovable, a company growing revenue this fast with this much enterprise validation is a meaningfully lower-risk bet than it looked a year ago. It doesn’t offset the security caveats below.
Now in effect: model training is on by default on Free and Pro
This is the most consequential thing on this page right now, and the deadline has passed — the policy took effect today, September 9, 2026. If you are on Free or Pro and never opted out, your content from today onward is in scope. Opting out now still works and still costs you nothing, but it only excludes content going forward; it does not retract anything already collected. Do it anyway, and do it now rather than later.
From September 9, 2026, Lovable’s updated privacy policy lets it use customer data from Free and Pro plans to train and improve its AI models — unless you opt out. “Customer data” is broad: prompts including attached images and files, code, project files, hosted applications, configurations, generated outputs and usage data (Lovable docs).
Excluded: your app’s end-user data, which stays in your project’s own database, and your account and billing details. Also excluded — by default, with no action needed — is all Business and Enterprise workspace data, which is governed by the organisation’s DPA instead.
To opt out on Free or Pro, open Account settings → AI model training and disable Use my Lovable content for model training. It is free and costs you no features. One thing that catches people out: the setting is account-level, so each person in a shared workspace controls only their own. Tell your co-founder.
Separately, from the same date Lovable may share limited pseudonymized identifiers with advertising platforms — not project contents. Consent-based in the EEA, UK, Switzerland and Brazil; opt-out via the “Do Not Sell or Share My Personal Information” footer link in the US.
Full breakdown: Lovable starts training on your projects September 9.
New in August 2026: /goal runs for up to 10 hours and won’t stop to ask you anything
This landed on August 30 and it is the biggest change to how Lovable bills you since credits themselves (changelog).
Type /goal at the start of a build message — or pick Goal from the / menu — and describe what you want. Lovable then works on that single message for up to 10 hours, without pausing to ask you questions, and builds the finished version of what you asked for. Lovable’s own wording on the cost is unusually direct: a goal “costs noticeably more than a regular build message.”
The only brake is the credit check-in feature described below, and Lovable confirms check-ins still pause a goal run at your check-in level. So before you use this: make sure you never dismissed check-ins with “Don’t ask again,” and know that the level is a whole number between 20 and 100,000 credits set once per account and applied in every workspace you belong to.
Used well this is excellent — it removes the failure mode where the agent stops to ask a technical question you can’t answer, and it’s a fair trade against a contractor day. Used carelessly it is an unsupervised working day billed to your balance. Don’t point it at auth, payments or a live database, and don’t run your first one overnight. Full breakdown: your agent can now run for 10 hours without asking you anything.
Also new: custom connectors for any API, GitLab, and push notifications
Four connector changes in six days, and together they close most of the “but can it talk to my system” objection (changelog).
Custom connectors (August 31) are the significant one. Workspace admins and owners on any plan can now build a connector for any REST API: in Connectors, hit +, choose Custom connector, then describe where requests go, how the API expects credentials, and optionally attach knowledge files that teach Lovable how to call it. It lands in your workspace catalogue and members use it like a built-in. Describing an API in plain English instead of writing an integration is exactly the right shape for this audience, and putting it on every plan rather than gating it to Business is a genuinely good call.
GitLab API and Firebase Cloud Messaging connectors (August 28). GitLab covers projects, branches, commits, files, issues, merge requests and pipelines across GitLab.com, Self-Managed and Dedicated — useful for triage boards and delivery dashboards. Firebase Cloud Messaging sends push notifications to a device or a topic, including browser push. Both support per-user access, where each person using your published app connects their own account.
Priority processing now works on Gemini chat models (August 31), not just OpenAI. Ask Lovable to make an AI feature respond faster and it uses priority processing rather than quietly downgrading you to a smaller model. It carries a premium price — worth knowing before you ask for “faster.”
Two smaller quality-of-life fixes worth noting: the preview no longer reloads after every change (August 28), so element selection survives between edits and you can make several visual tweaks in a row — a real irritation removed. And you can now grab the mobile app from Settings → Devices & apps (September 2), which shows QR codes for the iOS and Android listings.
New in September 2026: buy a domain from chat, and connectors from a pasted API key
Three additions on September 1, all of which remove a step that used to send non-technical users somewhere else (changelog).
Domains without leaving the project. Describe the kind of name you want and Lovable shows what’s available with prices; picking one continues in checkout. Already own a domain? It connects that instead. There’s a confirmation card before it buys or connects anything, and purchasing is limited to workspace admins and owners on paid plans. For an audience that historically loses a weekend to DNS, this is a real quality-of-life win.
Paste an API key, get a connector. When Lovable recognises which tool a pasted key belongs to, it offers to set up a workspace connector for it — reusable across projects, with control over who else can use it. Your key is still saved as a project secret either way.
Lovable in Slack now works on Enterprise, which means it’s available on every plan.
Four more on September 3. Insights (Settings → Workspace → Insights) shows how your workspace actually uses Lovable over the last 30 days against the 30 before: visits to published apps, active apps, active builders, connections added, top apps ranked by visits, and every member listed by edits, exportable to CSV. It’s Business and Enterprise only and it doesn’t burn credits. If you’re running a team on Lovable and have been guessing at adoption, this is the number you were guessing at.
The other three are smaller. The dashboard sidebar now opens inside the editor — hover the top-left menu icon, or press [ — so you can switch workspaces, search, and reach Connectors and Settings without leaving the project. Your app’s AI features can now generate video with Gemini Omni 1.1 Flash, including editing and extending clips your users upload. And you can raise the storage upload size limit to 5 GB (the default is 2 GB) under More → Cloud → Storage, or just ask in chat — it asks for approval before changing it.
New in August 2026: You can finally see what a build is costing you mid-run
The most useful thing Lovable shipped in the second half of August isn’t a feature, it’s a fix for the complaint that shows up in every thread about this tool: you send a prompt, the agent works for four minutes, and you find out what it cost after the credits are gone. Three changes, in sequence, close that loop (changelog).
Credit check-ins (August 17, beta). When a single message crosses a threshold — 20 credits by default — Lovable pauses and shows what it’s spent so far. Continue, raise the threshold, or Wrap up and have it finish what’s in flight without starting anything new. It’s a check-in, not a hard cap: a run can drift slightly past the level before pausing. Configurable in account settings, or dismissible with Don’t ask again.
Running out of credits pauses instead of failing (August 18). Hit zero mid-message and the work stops and waits rather than dying. Top up and it resumes where it left off. If you can’t manage billing, the card says Ask an admin and offers Resume once credits land. No deadline.
Live time and cost (August 25). Open More options under any in-progress message to see time spent and credits used so far, without waiting for it to finish.
Read together, this is Lovable admitting the credit model was opaque and doing something about it. It’s still worth watching the number yourself — a 20-credit default check-in is not the same as a spend limit, and nothing here stops a badly-scoped prompt from being expensive. But “I got billed for a run I would have killed at minute two” is now a solvable problem rather than a structural one. Similar controls landed in Cursor and Claude Code in the same month; the whole category is converging on cost visibility at the run level.
New in August 2026: Your app’s users can connect their own accounts
The other significant thread. App user connectors let each person using your published app connect their own account with a third-party service, so the app reads and writes only what that user can reach, under their permissions — rather than everyone sharing one connection you set up. Google Workspace came first; Amazon Redshift landed August 19 (per-user queries via your identity provider, requires IAM Identity Center) and GitHub on August 24 (one OAuth app for your workspace, each user signs in with their own account).
This is a bigger deal than it reads. Building per-user OAuth by hand — token storage, offline access, per-identity routing — was the wall where most non-technical founders stopped. Lovable keeps credentials server-side in its connector gateway; your generated app never receives them.
What it does not do is get you past the provider’s review queue. Sensitive scopes mean a review; restricted scopes like gmail.readonly mean an annual paid security assessment. Lovable published a walkthrough of one builder’s Google verification on August 20, and we’ve written the founder-facing version: the review nobody budgets for. Budget weeks, not days.
Also worth knowing from the same stretch: design systems moved to all paid plans (August 19), a Figma plugin now exports frames straight into Lovable (August 21), and Lovable can use your own connected service account while building so it inspects real schemas instead of guessing (August 19, private to you, revocable).
Correction: trust centers are now off by default (August 17)
The section below describes trust centers as automatic for every published app. That changed on August 17: the trust page is now disabled by default, and pages that were already live went offline. To publish yours, enable Trust center in Project settings → Publishing. It applies to your current published version within a few minutes — no republish needed — and only project admins and owners can change it.
If you turned a trust page on for a buyer’s security review between August 5 and August 17 and haven’t checked it since, check it. It is probably a 404 right now.
New in August 2026: A $400M Series C at a $13.3B valuation
On August 12, Lovable confirmed it raised $400 million in Series C funding at a $13.3 billion valuation, roughly double its December mark and a jump reported for weeks before it closed. Menlo Ventures led the round, with the Scaleup Europe Fund (managed by EQT) co-leading; Tencent, Balderton, Carmignac, Kaszek, and returning backers Accel, CapitalG, DST Global, HubSpot Ventures, and Salesforce Ventures also joined. TechCrunch and Bloomberg both confirmed the figures.
The numbers behind it are the part that matters for you. Lovable says annual recurring revenue has nearly tripled from $200 million and is tracking toward $600 million by the end of August, with more than 60 million projects built since launch and over 900 million monthly visits to Lovable-built apps. Translation: the platform you’d be committing a product to is not a cash-burning experiment that might vanish in a funding winter. It has real revenue, deep-pocketed investors, and the runway to keep shipping. That’s a genuine reason to worry less about platform risk than you would with a smaller tool. It does not change the day-to-day product, and it does not retire the security caveats below. For the founder-facing breakdown, see What Lovable’s $13.3B round means if you’re building on it.
New in August 2026: Trust centers for every app, and a Cerebras deal
Two announcements on August 5, both worth knowing about, though only one changes what you can do today.
Trust centers (August 5) are the more useful of the two. Every app you publish to public now gets a dedicated security page at your app’s own address (YOURAPPURL/.well-known/trust.html), generated automatically by Lovable. There’s nothing to fill in: Lovable inspects your live deployment and reports what it actually finds. The page lists observed controls a security reviewer would ask about, HTTPS enforcement and HSTS, a valid TLS certificate, Content Security Policy, clickjacking and MIME-sniffing protection, secure cookies, dependency vulnerability checks against Google’s OSV database, a CycloneDX software bill of materials, row-level security coverage on your database tables, and whether automated security fixes and a connected Aikido assessment are in place. Source: Lovable blog.
Why this matters for the site’s audience: if you sell to businesses, someone eventually runs a security review before they’ll commit, a customer, an investor doing diligence, or a client’s IT team. Until now your answer was a questionnaire and your word. A trust center gives a buyer a page they can check themselves, which is exactly the kind of credibility a two-person company could never manufacture before. Two honest caveats. First, this is informational, not a certification, a green row means Lovable observed a control, not that your app is audited or compliant, and the page says so itself. Second, it currently works only for newly published projects (legacy projects are coming), and your app’s own code can’t edit or restyle the page. Treat it as proof of platform-level hygiene, not a substitute for the independent security review this review still recommends before you store regulated data or real customer PII.
The Cerebras partnership (August 5) is future-facing. Lovable is moving its most latency-sensitive workloads onto Cerebras’s Wafer-Scale hardware in phases, aiming for dramatically faster response times by 2027. The pitch is less waiting between prompt and result so you stay in the build loop. There’s nothing to try today, it’s an infrastructure investment, but it signals where the speed of the tool is headed. Source: Lovable blog, Cerebras press release.
New in June 2026: Google Cloud deal, Reusable Skills, and Subagents
Three things in the first week of June that meaningfully change Lovable’s trajectory.
The Google Cloud deal (June 3) is the biggest headline. Lovable and Google signed a multiyear agreement that expands Lovable’s infrastructure footprint on Google Cloud by 5x and includes expanded access to Anthropic Claude, the model family Lovable runs on. The deal, reported by TechCrunch, is partly infrastructure (more Google Cloud capacity as Lovable scales) and partly a signal: Lovable is building the kind of enterprise relationships that start to look like defensible distribution. For builders, what changes is resilience at scale: more capacity means fewer rate limits during traffic spikes. It also confirms Lovable isn’t a scrappy startup running on rented compute; it’s on a commercial rail that Google has a financial interest in keeping healthy.
Reusable Skills are now live. You can create a skill, a packaged set of instructions and context, in workspace settings, upload an existing one, or ask Lovable to save a workflow you’ve used repeatedly as a skill. The immediate use case: if you always start projects with the same component patterns, data models, or integration setup, you can now encode that once and re-apply it without re-prompting from scratch. Teams benefit most, but solo builders who work across multiple products in the same space will find it cuts early-project setup time significantly. Source: EdTech Innovation Hub.
Subagents extend what Agent Mode can do. When Lovable’s agent hits a task that benefits from parallel research or exploration (understanding how a third-party API works, checking whether your schema handles an edge case) it can now spin up subagents to investigate those threads simultaneously rather than working them sequentially. In practice this means Agent Mode tackles complex tasks more coherently and with fewer “I need to pause and look this up” mid-task loops. Source: Lovable changelog.
New in May 2026: Agent Mode, Google connectors, and Multiplayer go live
Three updates shipped May 18–21 that change what Lovable can do in meaningful ways, not just marginal feature additions.
Agent Mode (Beta, May 19) is the most substantive. Previously, Lovable’s AI would generate code in response to each prompt but couldn’t plan or self-direct across multiple steps. Agent Mode changes that: you give Lovable a larger task (“add a Stripe billing portal with three subscription tiers and a cancel flow”) and the agent breaks it down, executes each step in sequence, inspects its own output, and continues until it’s done. It uses usage-based pricing rather than fixed credits, so simpler requests cost less than one credit while complex multi-step builds can cost several. For founders who were managing Lovable by breaking prompts into small chunks to control outcomes, Agent Mode should reduce that overhead significantly, though it requires more trust in the AI’s judgment mid-task. Source: Lovable blog.
Lovable x Google connectors (May 21) lets you connect your Lovable project to Google Workspace services (Google Sheets, Google Drive, Gmail, and Google Calendar) through a native connector rather than building an integration from scratch. For small businesses and solo founders who store operational data in spreadsheets or run on Google Workspace, this closes a real gap. Building a dashboard that reads from a live Google Sheet, or an app that creates calendar events, used to require a Lovable-to-Make-to-Google pipeline. Now it’s a connector setting. Source: Lovable LinkedIn announcement.
Multiplayer (May 18) lets multiple people edit the same Lovable project simultaneously, either with full edit access or review-only access, and includes team workspaces for shared projects across an organization. This makes Lovable less of a solo-founder tool and more of a collaboration surface. For a two- or three-person founding team where one person is product-minded and one is more design-focused, being able to work on the same app at the same time without stepping on each other is a real workflow improvement. Multiplayer is available on Business and Enterprise plans. Source: Analytics India Mag.
The direction across all three: Lovable is expanding from “fast solo MVP tool” to “small team product development platform.” That’s the right move as the market matures and founding teams grow past one person.
New in April 2026: Lovable on iOS and Android
On April 28, Lovable launched native mobile apps on the App Store and Google Play. The app is free to download, syncs projects across phone and desktop, and lets you build by typing or by speaking. Voice prompts are first-class on mobile, which is genuinely useful when you’re standing in line at the airport and an idea hits. You can preview the result in the in-app browser, hand off to the agent to keep working in the background, and pick up on your laptop later without losing context.
The realistic boundaries are worth flagging up front. Apple won’t let the iOS app host generated apps directly, so production publishing still happens from the web. The mobile app previews and iterates, but you’ll go to lovable.dev to deploy. The mobile editor is also intentionally narrower than the desktop one: you can prompt, preview, edit copy, and approve agent-suggested changes, but most fine-grained controls (Design View tweaks, MCP server config, deeper code edits via the GitHub integration) are still desktop-first. Treat the mobile app as the capture and approval surface, not a full replacement for the web editor.
What changes for non-technical founders: the friction between “I had an idea” and “the agent is now building it” drops to nearly zero. Voice prompting on mobile is the right modality for early ideation: describe the app for a minute, let the agent draft a starting point in the background, then review and refine on a real screen later. Whether that meaningfully changes outcomes depends on your workflow. Founders who already work in tight, focused desktop sessions probably won’t change much. Founders whose best ideas show up while walking, driving, or waiting in line just got a real tool for that.
New in April 2026: Lovable 2.0 and a built-in security scan
On April 24, Lovable published its official response to the April 2026 incident and shipped Lovable 2.0, headlined by a new in-product security scan that checks your project for common misconfigurations before you invite real users. The scan covers whether Row-Level Security is enabled on Supabase tables, whether public endpoints are exposing data that shouldn’t be public, and whether API keys and secrets are stored correctly. Every project gets it for free and it runs automatically on publish.
The honest caveat: early third-party reporting suggests the scanner flags the presence of RLS without verifying the policies actually do what they should. That gap matters. A table can have RLS “enabled” and still leak data if the policy is written wrong. Treat the green checkmark as a sanity check, not a security sign-off, and combine it with the Aikido pentest integration before you onboard paying customers or store regulated data. For most validation-stage builds, the new scan is a genuine improvement over “you’re on your own.” For anything past validation, the same rule as two weeks ago still applies: pay for an independent security review before go-live.
New in April 2026: A serious security disclosure you should read before building
On April 20, a security researcher published a credible claim that a Broken Object Level Authorization (BOLA) flaw in Lovable’s API let any free account read other users’ source code, database credentials, AI chat histories, and data, specifically on “public” projects created before Lovable’s February permissions rework. The researcher reported it via HackerOne on March 3, where it was closed as a duplicate without Lovable patching the underlying issue on pre-existing projects. Lovable initially denied there was a breach, pointed at HackerOne, and attributed the exposure to “intentional behavior” plus unclear documentation. On April 21, the company issued a second statement that was closer to an apology but still laid significant blame on HackerOne, while confirming it has reverted the change that re-opened access to public-project chats. See our full write-up in Lovable’s April 2026 data exposure: what founders need to do now for the detailed timeline and the checklist.
What this means if you’re using Lovable today. The immediate hole for public projects has been closed. Private projects were not affected by this specific flaw. The harder question is trust: this is Lovable’s second major security story in under two months (see our Lovable security crisis guide for the February RLS story), and the initial response here was defensive before it was corrective. That doesn’t make Lovable unusable. It means the same rule as before applies, only louder: don’t store real customer PII, payment credentials, or sensitive business data in a Lovable-built app without an independent security review. For validation-stage MVPs with fake data, Lovable is still the fastest path. For anything past validation, bake a security pass into your launch checklist.
New in April 2026: Chat Mode, follow-up questions, and Lovable Payments
Two launches in the past week are worth flagging for day-to-day users. First, Chat Mode (April 17) lets you start a new project by conversing with the agent about your idea before a single line of code is generated. Lovable will ask follow-up questions about scope, auth model, core entities, and layout preferences, and only build once you’ve confirmed a direction. The net effect is fewer “that’s not what I meant” iteration loops and lower credit burn on early prompts. Turn it on from the new-project picker; it’s opt-in.
Second, Lovable Payments (April 13) lets apps built in Lovable accept payments from 200+ countries with VAT and sales tax handled for you. Paddle is the default merchant of record; Stripe and Shopify are supported as integrations. You can configure one-time payments or subscriptions in a few prompts and run a sandbox-mode test flow before going live. For founders who used to hit a wall the moment they needed a real checkout, this is the cleanest path to collecting revenue inside a Lovable-built app.
New in April 2026: Claude Opus 4.7 support and a visible response to Anthropic
On April 16, Lovable rolled out Claude Opus 4.7 as the default model across the platform. In Lovable’s own benchmarks, tasks complete in roughly 40% fewer turns, which translates directly into fewer credits consumed per build. To sweeten the transition, every paid user got double credits through the end of April. That discount wasn’t incidental: it landed the same week leaks revealed Anthropic is building an in-chat app builder of its own, and the same week Anthropic officially launched Claude Design. Lovable staff reportedly worked overnight to ship the upgrade.
The competitive context matters if you’re evaluating the tool today. Lovable’s moat was “fastest path from idea to working SaaS for non-coders.” Anthropic is now actively trying to collapse that into Claude itself. For now, Lovable’s output quality, Supabase-backed architecture, and team-focused features (MCP servers, Design View, SSO) still make it the more mature choice. But the gap is shrinking, and that should factor into how you think about tool lock-in.
New in April 2026: MCP servers, Design View, and $400M ARR
Three things happened in the past few weeks that are worth knowing about.
First, Lovable launched MCP server support, which sounds technical but has real practical value. MCP (Model Context Protocol) lets Lovable read from your existing work tools: Jira tickets, Confluence docs, Notion pages, Linear issues, and n8n workflows. Instead of copy-pasting a PRD into chat, you connect your Notion workspace once and Lovable reads the context directly. For teams that live in project management tools, this cuts the overhead of translating specs into prompts significantly. Business and Enterprise plans can also add custom MCPs. This is the first sign that Lovable is moving beyond “solo founder builds an MVP” and toward “small team ships a real product.”
Second, a new Design View brings visual editing into one place: themes, image generation, and layout controls that previously required prompting. Themes let you define brand standards (colors, typography, spacing) once and reuse them across your workspace. You can create multiple themes and switch between them without re-prompting. It’s a meaningful step toward Lovable feeling like a proper design tool rather than a chat window with a side preview.
Third, Lovable added built-in penetration testing in partnership with Aikido Security. You can now run an automated security audit against your Lovable-built app. A swarm of AI agents attempts to exploit OWASP Top 10 vulnerabilities, privilege escalation issues, and data exposure gaps, then generates a formal report suitable for investor due diligence or SOC 2 purposes. It costs $100 per test and takes one to four hours. For founders shipping to real users, this is meaningful: the common criticism of vibe-coded apps (that they’re insecure by default) now has a practical counter. Enable Aikido in your project settings under Connectors to access it.
Second, Lovable announced it has reached $400 million in ARR, up from $200 million at the end of 2025, quadrupling in roughly four months. CEO Anton Osika also announced the company is actively seeking acquisitions, looking for “builder-first, high-agency teams” to bring in-house. The $6.6 billion valuation and the M&A posture signal that Lovable is playing the long game: not just a builder tool but an attempt to own the full stack of how non-technical founders build software.
None of this changes the day-to-day experience of using Lovable. But it does mean you’re building on a platform with significant resources behind it, which matters when you’re deciding whether to commit a real product to it.
What Lovable actually builds
When you describe an app to Lovable, you don’t get a static mockup or a frontend shell. You get a React application wired to a Supabase backend, with real authentication, a Postgres database, row-level security, and API routes. The gap between “it looks like an app” and “it is an app” is where most no-code tools fail silently. Lovable closes it.
For an MVP, that matters enormously. You can share a Lovable-built app with real users, gate it behind auth, persist data, and iterate based on what you learn. Most tools in this category produce demos. Lovable produces software.
The editing experience
The workflow is chat-driven: you describe what you want, Lovable generates the change, and a live preview updates in seconds. There’s version history with undo. There’s a GitHub integration so developers can pick up where you left off. There’s even a “select element” mode where you can click on something in the preview and describe changes to it directly.
The iteration speed is legitimately remarkable. Experienced Lovable users report going from blank canvas to something shippable in four to six hours. That’s not a marketing number. It’s consistent with what the tool actually delivers on straightforward SaaS projects.
New in April 2026: Pricing changes
Lovable updated its pricing structure this month. The old $20/month Starter and $50/month Pro plans are gone. The current tiers are: Pro at $25/month (100 monthly credits, standard features), Business at $50/month (100 credits plus SSO, priority support, and additional seat options), and Enterprise at custom pricing for larger teams. If you were on the old Starter plan and were happy at $20, you’ll want to evaluate whether the new $25 Pro still makes sense. The credit count is the same, but the price bump is real.
Pricing: what you actually need to budget
The free tier gives you 5 messages per day. That’s enough to explore the tool, not enough to build anything real. For serious MVP work, the $25/month Pro plan is the entry point. It gets you 100 credits per month, which sounds like a lot until you’re mid-iteration on a tricky feature.
Heavy users, meaning founders actively building and iterating, will find the Business plan at $50/month adds SSO and priority support but not unlimited credits. If you’re treating Lovable as your primary development environment, budget at least $25/month and potentially $50 if your team needs shared workspace access. The math still beats hiring a freelancer for a weekend.
Where it falls short
Lovable’s biggest weakness is its ceiling. Once you need something genuinely custom (a multi-step webhook flow, a custom payment integration that goes beyond Stripe basics, real-time features with WebSockets) the AI starts struggling. It doesn’t fail loudly; it generates plausible-looking code that subtly doesn’t work. That’s more dangerous than an obvious error.
The debugging experience also trails behind the authoring experience. When something breaks, you’re reliant on pasting errors into chat and hoping the AI reads the problem correctly. Sometimes it does. Sometimes it goes in circles. If you’re not a developer, knowing when to stop prompting and call in a human is a skill you’ll need to develop.
What “I don’t code” really means here
You don’t need to write code to use Lovable effectively. But you do need to understand the architecture it creates, because when you hand this off to a developer (which you eventually will), they’ll need to understand it too. Supabase for the database, React for the frontend, Vercel for hosting: that’s the stack. An hour of reading on each will make you a far more effective Lovable user.
What people have built with it
- Plinq: a women’s safety SaaS built by a first-time non-technical founder; reached 10,000 users and $456K ARR.
- DummyForms: a no-code form builder with AI generation; placed third in Lovable’s 2024 hackathon and launched on Product Hunt.
- Kolbo.AI: a unified AI content platform (60+ models) built by a 3D artist with zero coding experience.
Browse the full gallery at Made with Lovable.
Verdict
Lovable is still the best tool available right now for validating a SaaS idea without engineering resources. If the alternative is waiting to hire a developer or learning to code, Lovable is the clear choice. The output is real, the iteration speed is competitive, and the cost is rounding-error territory compared to what a developer would charge.
The ceiling is real, but most founders never hit it during validation. Start there. If you build something people want, figure out the scaling problems then, and after the April 2026 BOLA disclosure, treat “the scaling problems” as including a proper security review. Don’t put real customer PII, payment credentials, or regulated data into a Lovable-built app you haven’t paid someone to pressure-test. That’s the honest bottom line right now.
Chat your way to a native iOS or Android app, then ship it to the stores in minutes
Build and ship iOS and Android apps by describing them: no Xcode, no App Store Connect, no code
A multi-agent AI app builder that assigns seven specialized AIs to plan, build, and deploy your product