Lovable and Replit built a working tool-lending app from our brief on 1 September 2026. Lovable’s and Replit’s generated apps also left the request dashboards public. The choice is how much control you need over the code and the computer running it.
Lovable generated six sample tools and working filters. We filled the form and submitted a request. The queue showed the new row.
Replit added categories, conditions and lender details. We submitted a borrow request and received a confirmation.
Limit of this test. These are two recorded builds. A working form doesn’t establish that the private details are protected.
The page listed both requests. Lovable suggested adding lender authentication. Lovable’s automatic check reported no issues. A separate dependency check listed one known issue across 53 packages.
The public lender desk listed the name, email, dates and note. The preceding form had promised those details would only reach the lender.
Limit of this test. This finding applies to these generated apps. The brief didn’t request authentication. It doesn’t show that Lovable or Replit is unable to protect a dashboard.
Our reading of the evidence
Lovable generates the app, manages its backend and publishes from one workspace.
GitHub sync still gives the team the code.
The catch: Earlier Lovable guidance described no existing-code import or terminal. Current independent confirmation remains unavailable here.
Choose Replit instead when its documented support meets your requirement. Lovable’s corresponding answer remains unconfirmed.
Start Lovable free →Replit gives developers a terminal, project imports and a choice of languages.
The team can work directly with the code and supported runtime.
The catch: Agent work and hosting use separate meters.
Choose Lovable instead when one managed React web app is enough and the team doesn’t need a terminal.
Start Replit free →An AI app builder: describe the app and Lovable builds a full-stack web app. Backend choices include Lovable Cloud or connected Supabase. The code syncs out to GitHub on every plan.
Lovable builds web apps. Earlier guidance described no terminal or existing-code import. Those requirements remain unconfirmed here. App conditions and workflow changes use prompts or code. Its backend choices include Lovable Cloud and connected Supabase.
Fine for a new web app. If you need an existing repository or a different language or runtime, compare Replit’s broader coding workspace.
Lovable ·
Question: Can a Lovable Pro builder offer purchases to users inside a customer-created mobile app made from their Lovable project?
Summary: On Pro, a builder can add web checkout to their Lovable web app via built-in Paddle or Stripe payments. That checkout works on mobile browsers and in PWAs. There is no native app store distribution from Lovable, and no native Apple IAP or Google Play Billing - those are unavailable through the platform.
Reviewed
Link to this sourceA full cloud development environment with an agent on top. Replit builds the app, and underneath there’s a terminal, project imports and hosting with a published rate card. Check your required language and framework.
Replit charges by what you use. Agent work bills per effort-based checkpoint, hosting bills per compute unit, and the free plan’s one published app takes its link down after 30 days. What a build costs is knowable only once it’s built.
Budget for Replit’s measured usage. Lovable sells a fixed credit allowance, but app use and outside services can still change the total.
Check the trade-offs
Findings from 1 September 2026.
| If you need to… | Lovable | Replit |
|---|---|---|
| Get a first app workingThe same tool-lending brief | Built the catalog, request form and dashboard after one design question. Recording and notes → | Built the app and filled the catalog with sample tools. Recording and notes → |
| Keep borrower details privateThe generated apps needed more work | The request dashboard opened without a login. Recording and notes → | The dashboard showed the borrower’s email without a login. Recording and notes → |
| Continue an existing projectBring the code you already have | Supports export. Earlier guidance described no existing-code import; current support remains unconfirmed. Vendor source ↗ | Imports projects from GitHub and other sources. Vendor source ↗ |
| Use a terminal or another languageControl beyond the generated web app | Earlier guidance described no terminal. Current terminal support remains unconfirmed here. Vendor source ↗ | A terminal in the workspace. Check the exact language and framework you need. Vendor source ↗ |
| Prepare a phone app for the storesWhat the builder does for you | Earlier guidance described outside packaging. Current built-in store packaging remains unconfirmed. Vendor source ↗ | Earlier guidance described native output through Expo. The complete store-packaging requirement remains unconfirmed. Vendor source ↗ |
Make the choice yours
| Commercial signal | lovable.dev | replit.com |
|---|---|---|
|
Same for Lovable and Replit
Free tier✓
Self-serve signup✓
Billing cyclesMonthly & annual
Official mobile appiOS & Android
| ||
| Entry paid price | $25/mo (Pro) | $20/mo (Core, or $17/mo billed annually) |
| What the meter counts | Build credits pay for builder work. Published pages are free to host; backend activity and in-app AI use Run credits. | Effort-based checkpoints for the agent, plus metered compute, requests & storage for hosting |
| What the free tier actually holds | 5 build credits/day (30/mo cap) + 20 Cloud credits + 4 AI credits monthly. The code editor is read-only | Daily agent credits to a monthly cap. 1 published app whose link goes down after 30 days, and most connectors locked |
| Full price list | Free $0 → Pro $25 → Business $50 → Enterprise (sales) | Starter $0 → Core $20 → Pro $100 → Enterprise (sales) |
| Team pricing | By credits, unlimited members on every plan | No seat fees: 5 builders on Core, 15 + 50 viewers on Pro |
| Published hosting rate card | Published pages are free to host. Backend activity and in-app AI use Run credits. | Printed in full: Autoscale $2/mo + $0.60 per 1M compute units, Reserved VM from $15/mo, static hosting free |
| Security posture (stated) | SOC 2 Type II + ISO 27001:2022 + GDPR | SOC 2 Type II + GDPR. ISO 27001 sits with Replit’s cloud provider, not Replit |
| Your work as training data | Lovable’s Free & Pro plans allow training on customer data from Sep 9, 2026 unless you flip the free opt-out toggle | Free-tier model providers may train on your prompts. Paid endpoints don’t, and no opt-out toggle surfaced |
| Named integrations found | 96 connectors live, and connecting them costs no credits | 450+ connectors, most needing Core or higher |
| Company behind the product | Lovable Labs Incorporated | Replit, Inc. |
Free tiers, self-serve signup, monthly and annual billing: the same on Lovable and Replit. Lovable’s $25 plan lists 100 credits. Published pages are free to host; backend activity and in-app AI use Run credits. Replit’s $20 buys $20 of credit against its published rates for agent work, compute and storage.
| Question | Lovable | Replit |
|---|---|---|
| What makes the price go up | You building. Each message costs credits by the size of the task, and the more you build in a month the bigger the tier you buy. | You building and serving. Agent work bills by effort per checkpoint, and the published app meters compute, requests and storage. |
| What the free tier holds back | The editor. Five build credits a day, and the code editor is read-only until $25. | Permanence. One published app whose link goes down after 30 days, and most connectors need Core. |
| What you can take with you | The code, in full. GitHub sync on every plan and self-hosting stated in the docs. The one-click download is paid. | Code and database exports. Full Git and a zip from the file tree on any plan. The database is standard PostgreSQL with a connection string. Moving the complete app, including its managed backend services, to independent hosting remains unconfirmed. |
You can start on Lovable or Replit for $0. These are starting plan prices. Lovable uses Build credits for builder work and Run credits for backend activity and in-app AI. Replit meters agent work and app usage.
On this pace Replit is the cheaper or equal option at every stage, by $5 a month. That compares the listed plan prices. Lovable hosts published pages for free; backend activity and in-app AI use Run credits.
Lovable and Replit are $0 at the stage you selected. Even the two $0s differ: Lovable’s free app stays up, Replit’s free link lasts 30 days.
Plan prices listed by Lovable and Replit on September 1, 2026. Replit’s $20 Core runs $17/mo billed annually; our own build that day metered $1.06 of Replit Core’s $20 monthly credit. Lovable’s and Replit’s usage allowances reset monthly, with top-ups or a higher tier for the heavy months. The live pages have the current numbers: lovable.dev/pricing · replit.com/pricing.
From our September 1, 2026 scan. A ✗ means the product won’t do it for you, not that it can’t be done. A — is something we couldn’t confirm either way, not a thing the vendor lacks.
| Capability | Lovable | Replit |
|---|---|---|
| Build it by describing it | ||
| Build apps & websites from plain language | Describe the app or change in project chat; Lovable generates and edits the app code, with a running preview for review. Builds consume credits and generated output needs testing. Builds consume credits and generated output needs testing. Requirement: Type what you want and get a working app back. Checked | |
| Point at an element and change it in plain words (Replit applies simple text and style edits without spending agent credits; Lovable bills them as chat) | Select an element and describe a change. Lovable bills these edits as chat. Sources: [7] Checked | Use Replit Design’s Visual Editor for supported layout and styling changes, and select an element to give Agent a targeted change request. Visual editing covers design. It doesn't replace app logic, data or testing. Visual editing covers design; it does not replace app logic, data or testing. Requirement: Click the thing that's wrong and say what you want instead. Checked |
| Images as input | Attach images as context or import the Figma design into Replit Design, then build the design into the app. The generated result needs review against the source design. The generated result needs review against the source design. Requirement: Give the builder a screenshot or mockup to use as the starting point. Checked | |
| Plan the product with AI before you build (billed on Lovable and Replit: Lovable’s Plan mode is 1 credit a message, and Replit says all agent interactions are billable) | Lovable: Plan mode lets you discuss the product before building. The recorded rate is one credit per message. Sources: [15] Checked | In Replit, use Plan Mode to discuss the requirements and approve the approach before Agent makes implementation changes. Requirement: Shape the feature list before anything is generated. Sources: [16] Checked |
| Community templates to start from | Open a public Lovable template or shared project and remix it into an independent copy, then customize it. Remixing is available on any plan. External services and data need their own setup. Remixing is available on any plan; external services and data need their own setup. Requirement: Open a working app somebody else built and make it yours. Checked | In Replit, remix a published community app from the Gallery or start with a supported template and customize the copy. Old language/framework template pages have been removed; Gallery remix and code import are current alternatives. Old language/framework template pages have been removed; Gallery remix and code import are current alternatives. Requirement: Open a working app somebody else built and make it yours. Checked |
| The agent tests the app in a real browser (Replit's browser testing covers full-stack JavaScript and Streamlit apps and turns off in Replit’s cheapest agent mode) | Ask Lovable to test a flow. Browser testing opens the app, interacts with it and records the results for review. Review which flows were tested. This isn't proof that every app behavior passed. Review which flows were tested; this is not proof that every app behavior passed. Requirement: The agent clicks through the generated app and fixes problems before you see the app. Sources: [20] Checked | In Replit, use App Testing to let Agent navigate the generated app in an actual browser, enter test data and fix reported issues. Review the tested flows. Automated testing doesn't establish that every requirement passed. Review the tested flows; automated testing does not establish that every requirement passed. Requirement: The agent clicks through the generated app and fixes problems before you see the app. Checked |
| The backend it gives you | ||
| A database set up for you (Lovable Cloud runs on a Supabase foundation; every Replit app carries managed PostgreSQL with 20GB of storage) | Enable Cloud and describe the required data; Lovable creates a managed Postgres schema that can be inspected and edited in the Database view. Database usage and Cloud credits apply. Review security policies. Database usage and Cloud credits apply; review security policies. Requirement: Your app’s data goes into a database the builder sets up. Checked | In Replit, ask Agent to add the managed SQL database, then inspect its schema and records with the database tools. Storage and database usage limits apply. Production and development recovery are distinct. Storage and database usage limits apply; production and development recovery are distinct. Requirement: Your app’s data goes into a database the builder sets up. Checked |
| Sign-up, login & accounts for your app's users (on Replit, end users sign in with Replit accounts by default, and app-native accounts take the Clerk integration. Lovable’s are your app’s own) | Lovable provides sign-up and login for accounts belonging to your app. Sources: [24] Checked | In Replit, ask Agent to add a supported login provider and configure the app’s sign-in flow. App-user identity is separate from the builder account and workspace identity. App-user identity is separate from the builder account and workspace identity. Requirement: Your users register and log in without you building auth. Checked |
| File storage & uploads | In Lovable, create Cloud storage buckets and upload flows, then configure public or private access to stored files. Private-file URLs are temporary signed links; Cloud storage usage is metered. Private-file URLs are temporary signed links; Cloud storage usage is metered. Requirement: Uploads stored and served for you. Sources: [31] Checked | In Replit, use App Storage for uploaded files and connect the SDK or generated app upload flow. Storage is metered. Lifecycle rules, object versioning and retention policies aren't built in. Storage is metered; lifecycle rules, object versioning and retention policies are not built in. Requirement: Uploads stored and served for you. Sources: [32] Checked |
| Server-side code (Lovable runs server-side code through serverless functions on Lovable Cloud, and Replit also runs real always-on servers as Reserved VMs)Different setup | Server-side code runs through serverless functions on Lovable Cloud. Sources: [24] Checked | In Replit, write or generate backend code in the project and publish it through a supported server deployment. Deployment resources and runtime compatibility apply. Deployment resources and runtime compatibility apply. Requirement: Logic that runs on a server, with no server of yours. Checked |
| Live updates for connected users | Lovable: The specific live-update or notification mechanism remains unconfirmed for this requirement. Requirement: Changes show up for everyone without a refresh. (Lovable lists realtime as a Cloud capability; on Replit the agent writes the realtime layer into your app's own code rather than providing a managed service) Checked | Replit: Agent writes the live-update layer into the app's code. It is not supplied as a separate managed service. Sources: [36] (Lovable lists realtime as a Cloud capability; on Replit the agent writes the realtime layer into your app's own code rather than providing a managed service) Checked |
| Checkout & subscriptions (Lovable and Replit need a paid plan: Lovable’s payments start at Pro, and Replit’s Stripe integration needs Core, where Replit’s free tier prompts an upgrade) | Lovable supports checkout and subscriptions on Pro and higher paid plans. Sources: [37] Checked | In Replit, connect the paid-plan Stripe integration, test with sandbox payments and connect the live Stripe account before accepting real payments. Core or Pro. Live provider activation and transaction fees apply. Core or Pro; live provider activation and transaction fees apply. Requirement: Charge one-time or recurring, inside the app you built. Checked |
| The automation inside | ||
| Scheduled jobs the platform runs for you | Ask Lovable for the action and schedule; Cloud jobs call the server-side code and show execution history. This is generated backend logic, not a visual trigger-and-action editor. This is generated backend logic, not a visual trigger-and-action editor. Requirement: Recurring work that happens on its own, on a schedule you set in plain words. (Lovable's Jobs bill Cloud credits per run; Replit's scheduled agent Routines need Core or higher) Checked | Replit runs scheduled background commands. Setting that schedule in plain language remains unconfirmed for this exact requirement. Requirement: Recurring work that happens on its own, on a schedule you set in plain words. (Lovable's Jobs bill Cloud credits per run; Replit's scheduled agent Routines need Core or higher) Checked |
| AI agents that act across your connected tools | Lovable: Connected tools can keep running app automations after the build, without another prompt. Sources: [43] (Replit’s agent builds other agents, Slack bots and Telegram bots, but they must be deployed to run, and most connectors need Core. Lovable’s connectors keep running automations without prompting) Checked | Replit: Runtime connectors are available. An autonomous app agent acting across connected tools remains unconfirmed. Requirement: An agent that reads and acts in the tools you've connected, after the build. (Replit’s agent builds other agents, Slack bots and Telegram bots, but they must be deployed to run, and most connectors need Core. Lovable’s connectors keep running automations without prompting) Checked |
| Emails & SMS sent by the app (Paid Lovable workspaces can send transactional email from your verified domain without a separate provider account. Resend remains another option. Twilio supplies SMS on an account you bring; Replit’s connectors mostly need Core.) | In Lovable, use the Resend connector for transactional email and Twilio for SMS from server-side app logic. Provider accounts, domain verification where needed, authorized credentials and messaging charges apply. Provider accounts, domain verification where needed, authorized credentials and messaging charges apply. Requirement: The app messages people on its own. Checked | In Replit, use an email integration such as Resend or SendGrid and the Twilio integration for SMS from the generated app. External connectors require Core or higher, and service permissions and messaging charges apply. External connectors require Core or higher, and service permissions and messaging charges apply. Requirement: The app messages people on its own. Sources: [44] Checked |
| The machine underneath | ||
| A real shell & terminal in the workspace | Lovable’s own guide states the boundary: no IDE, no terminal, no local setup. Lovable’s AI runs commands in an environment you can’t open Requirement: A command line inside the project, for anything the buttons don't cover. Later review: · Unconfirmed. Sources: [49] Checked | |
| Run any language or framework | Lovable fixes the project stack: TanStack Start for newer apps and React + Vite for older apps. To use a different framework, continue the work outside Lovable. Lovable: No. Requirement: Whatever language the job needs, not just one kind of web app. Newer apps use TanStack Start; older apps use React + Vite. Exporting to another tool does not change the frameworks supported inside Lovable. (Lovable’s documented project types are web apps, including TanStack Start and React + Vite projects. Replit provides a general-purpose runtime with language support through Nix.) Checked | Replit supports multiple languages and frameworks through General Agent or project import. Unrestricted support for any language or framework remains unconfirmed. Requirement: Whatever language the job needs, not just one kind of web app. (Lovable’s documented project types are web apps, including TanStack Start and React + Vite projects. Replit provides a general-purpose runtime with language support through Nix.) Checked |
| Install any package | Lovable supports compatible npm packages for its JavaScript app runtime. Installing any package without runtime or workspace restrictions remains unconfirmed. Requirement: Add the library the feature needs. Sources: [54] (on Lovable you ask in chat and Lovable installs public npm packages; on Replit you run the package manager yourself or let the agent do it) Checked | Replit supports package managers and dependency installation. Installing any package without runtime or workspace restrictions remains unconfirmed. Requirement: Add the library the feature needs. (on Lovable you ask in chat and Lovable installs public npm packages; on Replit you run the package manager yourself or let the agent do it) Checked |
| Import an existing repo and keep working on it | Lovable’s docs answer it directly: export only, no way to start from existing code. Replit imports from GitHub, Bitbucket, Figma, a zip, and from Lovable itself Requirement: Bring the code you already have, instead of starting over. Later review: · Unconfirmed. Sources: [56] Checked | In Replit, import a repository from a supported Git provider, then continue editing and running it in the Project Editor. Repository access and runtime compatibility are required. Repository access and runtime compatibility are required. Requirement: Bring the code you already have, instead of starting over. (Lovable’s docs answer it directly: export only, no way to start from existing code. Replit imports from GitHub, Bitbucket, Figma, a zip, and from Lovable itself) Checked |
| Hours-long unattended agent runs | Set a /goal in Build mode to let Lovable work for up to ten hours toward the requested result. It may pause for credit-cost approval or missing access. This isn't an unconditional promise of uninterrupted autonomous work. It may pause for credit-cost approval or missing access; this is not an unconditional promise of uninterrupted autonomous work. Requirement: Give the agent a large task and come back later. Sources: [59] (Replit's Agent 3 launch claimed up to 200 minutes on its own. Lovable documents a 10-hour maximum per Build message. Lovable's beta credit check-ins pause at 20 credits by default. Raise or disable that setting for longer unattended runs. An empty credit balance still pauses Lovable.) Checked | Replit: Autonomous and background work are documented. The stated hours-long unattended duration remains unconfirmed. Requirement: Give the agent a large task and come back later. (Replit's Agent 3 launch claimed up to 200 minutes on its own. Lovable documents a 10-hour maximum per Build message. Lovable's beta credit check-ins pause at 20 credits by default. Raise or disable that setting for longer unattended runs. An empty credit balance still pauses Lovable.) Checked |
| Choose the AI model behind the builder Earlier finding: (Replit's Power and Max modes include a model selector. Lovable's Build and Plan modes don't offer a model selector.)Different availability | Lovable: Choose the AI model the builder uses. Can I choose which model Lovable uses in Build mode or Plan mode? No. Lovable manages the underlying model used by the agent in Build mode and Plan mode . The agent runs on current frontier models, and Lovable rolls out model upgrades automatically to all users, so there is no setting to switch the agent between specific models. If you want to choose a specific model for AI features inside your own deployed app, see AI features for your app , which lists the supported models you can call from your app. Can I choose which model Lovable uses in Build mode or Plan mode? No. Lovable manages the underlying model used by the agent in Build mode and Plan mode . The agent runs on current frontier models, and Lovable rolls out model upgrades automatically to all users, so there is no setting to switch the agent between specific models. If you want to choose a specific model for AI features inside your own deployed app, see AI features for your app , which lists the supported models you can call from your app. No. The built-in AI connector adds AI features to the apps you build with Lovable. The Lovable agent is what helps you build and edit your project.The models listed on this page are available for AI features inside your app. They are not the models Lovable uses to write, edit, or reason about your code. Checked | In Replit, on eligible paid plans, choose an available primary model in Power or Max mode; Free Mode uses automatic routing. Core or Pro for manual selection. Model availability varies by rollout, workspace policy and authorization. Core or Pro for manual selection; model availability varies by rollout, workspace policy and authorization. Requirement: Choose the AI model the builder uses. Checked |
| Ship it & own it | ||
| One-click deploy & managed hosting (free on Lovable and Replit to start, but Replit’s free tier gives one published app whose link goes down after 30 days) | Lovable publishes to managed hosting, with a free starting option. Sources: [63] Checked | In Replit, use the Publishing tool to deploy the app and manage its live domain, access and server settings. Deployment type and resource usage determine cost. Unpublished changes stay in development. Deployment type and resource usage determine cost; unpublished changes stay in development. Requirement: Publish to live hosting without touching a server. Checked |
| Custom domains & SSL (custom domains are paid on Lovable; Replit needs a published deployment first) | Connect your own domain with HTTPS on a paid Lovable plan. Sources: [65] Checked | |
| GitHub sync (Lovable’s sync is two-way but starts export-only, one branch at a time. Replit is full Git: pane, CLI and per-file history)Different setup | Lovable: Two-way GitHub sync begins by exporting the project and follows one selected branch at a time. Sources: [68] Checked | In Replit, use the Git pane to connect a remote repository, commit changes, pull updates and push the project to the remote. This is Git synchronization through explicit operations, not an unconditional always-on automatic sync. This is Git synchronization through explicit operations, not an unconditional always-on automatic sync. Requirement: The generated code syncs to a repository you control. Checked |
| Edit the code inside the product (Lovable’s free-plan editor is read-only, so editing needs a paid plan. Replit’s editor is free on every plan) | Lovable: Editing requires a paid plan. The free-plan code editor is read-only. Sources: [70] Checked | |
| Package for the iOS & Android app stores | Lovable documents no built-in flow that packages and submits to the stores, and Lovable’s paths are a home-screen PWA or wrapping the export yourself. Replit generates native output through Expo and walks you through submission on your own Apple developer account Requirement: The builder prepares the store submission, instead of you packaging the app yourself. Later review: · Unconfirmed. Sources: [72] Checked | iOS submission is documented. Publishing to Google Play from Replit remains unsupported, so the combined two-store requirement is unconfirmed. Requirement: The builder prepares the store submission, instead of you packaging the app yourself. Sources: [73] (Lovable documents no built-in flow that packages and submits to the stores, and Lovable’s paths are a home-screen PWA or wrapping the export yourself. Replit generates native output through Expo and walks you through submission on your own Apple developer account) Checked |
| Version history, restore & rollback (Lovable's revert restores code but not database data; Replit's checkpoints can roll the database back too)Different limits | Lovable: Reverting restores the app’s code, but does not restore database data. Sources: [74] Checked | In Replit, restore Agent checkpoints to recover files and conversation context. Optionally restore the development database too. Production database recovery is separate. Later changes are removed. Production database recovery is a separate process; changes after the selected checkpoint are removed. Requirement: Step back to any earlier version when something breaks. Sources: [75] Checked |
| Download and self-host your codebase | In Lovable, download app code or sync GitHub to host it elsewhere. Moving the whole app also requires migrating its database, authentication, stored files, secrets and service settings. Moving the complete app includes database, authentication, storage, secrets and service configuration; a repository export alone is not a backend migration. Requirement: Take everything and run it anywhere. (Lovable’s one-click download is paid, so GitHub sync is the free way to get the code out. Replit zips from the file tree on any plan) Checked | Replit supports code export and Git repositories. Moving the complete app, including managed databases, storage and authentication, to independent hosting remains unconfirmed. Requirement: Take everything and run it anywhere. (Lovable’s one-click download is paid, so GitHub sync is the free way to get the code out. Replit zips from the file tree on any plan) Checked |
| Data & integrations | ||
| One-click connectors to the tools you use (Lovable lists 96, and the connectors cost no credits to use. Replit lists 450+, and most need Core or higher) | Authorize connections to supported tools. The connectors themselves do not use Lovable credits. Sources: [43] Checked | In Replit, authorize a supported connector and ask Agent to use it. App connectors expose the provider to generated runtime code. External connectors require Core or higher. Custom connectors require Pro or Enterprise. External connectors require Core or higher; custom connectors require Pro or Enterprise. Requirement: Authorize once and the connection works. Checked |
| Model Context Protocol (MCP), both directions | In Lovable, connect an external MCP server to builder chat or use Lovable’s MCP server from another assistant. Workspace permissions apply. Builder tools and published-app connections have different uses. Custom connector availability and workspace governance apply; builder tools and published-app tools have different scope. Requirement: AI tools like Claude can operate the builder. The builder can also connect to MCP servers. Checked | In Replit, connect external MCP tools or use Replit’s MCP server from another assistant to create, update and publish apps. Server authorization, permissions and provider charges apply. Remote MCP requires compatible authorization; each server’s permissions and service charges apply. Requirement: AI tools like Claude can operate the builder. The builder can also connect to MCP servers. Checked |
| APIs generated for your app's data | Lovable: Each server function has a copyable API address that other software can call. Sources: [41] (Lovable gives each server function a copyable API address. Replit Agent can generate APIs in your app's code. Ask for the API, review access rules and deploy the app.) Checked | Replit: Generated backend code is possible. Automatic public APIs for the app’s data remain unconfirmed for this app feature. Requirement: Your app's data reachable from other software, on an address you can copy. (Lovable gives each server function a copyable API address. Replit Agent can generate APIs in your app's code. Ask for the API, review access rules and deploy the app.) Checked |
| Bring your own backend (Lovable connects your own Supabase on every plan. Replit's external data connectors are Enterprise-only, though Replit’s runtime can reach any service you code against)Different setup | In Lovable, connect your own Supabase backend on every plan. Sources: [85] Checked | In Replit, connect the app to an external database or backend using server-side configuration and secrets. The service needs a compatible interface. Migration, access rules and credentials need setup. The backend must provide a compatible interface and reachable credentials; migration and security setup are the app owner’s responsibility. Requirement: Point the app at a backend you already run. Checked |
| Import a Figma design and build from it | In Lovable, import through the Figma plugin, upload a .fig file or connect Figma desktop MCP. The MCP route needs both desktop apps. Each method imports different design detail. The Figma MCP path requires Lovable desktop and Figma desktop; each import path carries different design detail. Requirement: Start from the design your designer already made. Sources: [12] Checked | Attach images as context or import the Figma design into Replit Design, then build the design into the app. The generated result needs review against the source design. The generated result needs review against the source design. Requirement: Start from the design your designer already made. Checked |
| Encrypted secrets for the app's API keysDifferent setup | Store credentials in Secrets; Replit encrypts them and exposes them to the server process as environment variables. Do not copy secrets into browser code, logs or shared output. Do not copy secrets into browser code, logs or shared output. Requirement: Keys stored where the browser can't see them. Sources: [86] Checked | |
| Design, content & findability | ||
| Visual edits without prompting | Lovable: Inline text edits are direct. Broader visual design changes without prompting remain unconfirmed. Requirement: Change how it looks by clicking, not by writing another prompt. Replit's visual editor changes text, colours and spacing without spending credits. Lovable’s Visual Edits changes appearance and inline text. App conditions and workflow steps need prompts or code. Our 1 September record listed 100 free inline-text edits a day; we have not rechecked that allowance. Read Lovable’s statementLovable · Question: Does Lovable itself provide a visual workflow builder in which I can choose the event that starts an automation? 1. Choosing a trigger using native visual controls Not available. Lovable does not have a native visual workflow builder on any plan. Automations are created by describing the trigger to the AI in Build Mode (for example, "when a new row is added to this table, send an email"), which generates the underlying code as Edge Functions or scheduled Jobs. Reviewed Link to this sourceRead Lovable’s statementLovable · Question: In that native visual workflow builder, can I choose the steps that follow the starting event? 2. Choosing automation steps using native visual controls Not available. There is no point-and-click interface for selecting or composing automation steps. Steps are generated by the AI based on your description. Reviewed Link to this sourceRead Lovable’s statementLovable · Question: Can I directly change an existing automation's steps in a visual editor, without asking AI to make the change? 3. Editing existing automation steps in a visual editor Not available. Modifying an existing automation requires prompting the AI to update it, or editing the generated code directly. Reviewed Link to this sourceRead Lovable’s statementLovable · Question: Can I directly change an existing automation's conditions in a visual editor, without asking AI to make the change? 4. Editing existing automation conditions in a visual editor Not available. Same as point 3 - changes to automation conditions go through AI prompting or direct code editing. In summary: Lovable's automation capability is entirely AI-driven. You describe what you want, the AI generates the code, and updates are made by re-prompting or editing code. There is no native visual workflow builder on any plan, including Pro. Reviewed Link to this sourceRead Lovable’s statementLovable · Question: Can a builder on Lovable Pro use native visual controls to define a condition and what their customer-created app does when that condition is met? To address this directly: Lovable does not have native visual controls for defining conditional logic or if/then behavior in a customer-created app as a standalone feature. The Visual Edits toolbar (in the preview) is strictly a UI appearance editor - it lets you select elements, edit text inline, draw annotations, and leave comments on the preview. It does not provide a condition builder, logic flow editor, or rule-setting interface of any kind. For conditional behavior in a customer-created app on Pro, the available routes are: - AI prompting (Build Mode): Describe the condition and outcome in natural language; Lovable generates and implements the corresponding code. This is the primary route and is available on all plans including Pro. - Code editing (Code tab): Direct access to the generated code is available on paid plans including Pro, for manual edits. There is no visual condition builder, logic panel, or if/then rule interface separate from AI prompting and code. No plan tier on Lovable unlocks such a feature, as it does not exist natively on the platform. Reviewed Link to this sourceSources: [89] Checked | Use Replit Design’s Visual Editor for supported layout and styling changes, and select an element to give Agent a targeted change request. Visual editing covers design. It doesn't replace app logic, data or testing. Visual editing covers design; it does not replace app logic, data or testing. Requirement: Change how it looks by clicking, not by writing another prompt. (Replit's visual editor changes text, colours and spacing without spending credits. Lovable’s Visual Edits changes appearance and inline text. App conditions and workflow steps need prompts or code. Our 1 September record listed 100 free inline-text edits a day; we have not rechecked that allowance.) Checked |
| Design systems & app-wide theming (Lovable's workspace design systems are paid plans; Replit's themes are per-app, with design-system import in Enterprise beta) | Lovable: Workspace design systems require a paid plan. Sources: [90] Checked | In Replit, create a design system with shared components and visual rules. Save it to the workspace and apply it to a new or existing app. Review the result against the design. Review how the system is applied to existing projects; design guidance is not a guarantee of perfect compliance. Requirement: Pick the look once and every screen follows it. Checked |
| Generate images & media inside the builder (Lovable generates images and video; Replit generates images, priced by Replit’s blog at about $0.04 each) | In Replit, ask Agent to create images or audio and add the assets directly to the project. Media-generation availability and usage charges depend on the model and plan. Media-generation availability and usage charges depend on the model and plan. Requirement: Media made in the builder instead of sourced elsewhere. Checked | |
| SEO controls & social previews (Lovable's SEO reviews run free on every plan; Replit's SEO Agent is for paid builders with a live deployment) | In Lovable, set search metadata and social previews. SEO reviews are free on every plan. Sources: [99] Checked | Ask Agent to add titles, descriptions and social-sharing metadata, and review the published app with Replit’s SEO tools. SEO ratings require publicly accessible deployments and don't guarantee rankings. SEO ratings require publicly accessible deployments and do not guarantee rankings. Requirement: Titles, descriptions and link previews you can actually set. Checked |
| Analytics for the published app (Lovable Cloud’s native analytics shows aggregate traffic. On Pro, beta checks look at code and visitor errors. Visitor replay needs an external service and tracking code. Replit’s uptime monitoring needs Core or higher.)Different setup | In Lovable, open Analytics to inspect visits, traffic sources and published-app activity. It starts collecting after publication. Analytics is included on all plans. Analytics is included on all plans. Requirement: See traffic and behaviour without adding a tool. Lovable Cloud’s native analytics shows aggregate traffic. On Pro, beta checks look at code and visitor errors. Visitor replay needs an external service and tracking code. Replit’s uptime monitoring needs Core or higher. Read Lovable’s statementLovable · Question: Can a builder on Lovable Pro monitor how their own live Lovable Cloud app performs from inside Lovable? 1. Native monitoring of a published Lovable Cloud app (from inside Lovable) There are two customer-visible screens in the Lovable editor: Project analytics (More → Analytics in the project toolbar): - Starts collecting automatically when you publish; no setup required - Measurements: Visits, Page views, Views per visit, Visit duration, Bounce rate - Breakdowns by Source (referrers), Page, Device, and Country - A "current visits" counter shows visits active in the last 5 minutes - Available on all plans; controlled by the Visitor analytics toggle in Project settings → General → Publishing (on by default) - UTM campaign parameters are not tracked; for funnel or campaign reporting, an external analytics tool (such as PostHog) would need to be added separately Project monitoring (Project settings → Project monitoring, currently in beta): - Background checks on a daily or weekly schedule (builder's choice) - Looks at project code for broken functionality, logic, or UI, and at recent visitor errors with code-level root-cause analysis - Alerts appear in the editor (above the project chat) and by email - Available on Pro, Business, and Enterprise; any project editor can enable or disable it per project - Uses Lovable credits per completed run (cost varies per run and is shown in the monitoring history) Reviewed Link to this sourceRead Lovable’s statementLovable · Question: Can that builder watch recordings showing what real visitors did in their own published app? 2. Session replay (visitor recordings) Not available natively. Lovable's built-in analytics tracks aggregate traffic only and does not record individual visitor sessions or build visitor profiles. To add session replay, the builder would prompt Lovable to integrate an external service (for example PostHog, Hotjar, FullStory, or LogRocket) by adding that service's tracking snippet to the app. This is external tool plus custom code; there is no native Lovable control for it. No Lovable plan restriction applies to adding external integrations; the external provider's own account is what is required. Reviewed Link to this sourceSources: [103] Checked | In Replit, enable Project Analytics for a supported Static, Autoscale or Reserved VM website and publish again. Default traffic metrics are included. Custom events and Agent analytics questions need a paid plan. Websites on supported Static, Autoscale or Reserved VM deployments; enable analytics and publish again. Custom events and Agent analytics questions require a paid plan. Requirement: See traffic and behaviour without adding a tool. Checked |
| Working as a team | ||
| Real-time collaboration (Lovable takes unlimited members on every plan. Replit seats collaboration: 5 on Core, 15 on Pro) | Lovable: Multiple people can work in the same project, with unlimited members on every plan. Sources: [106] Checked | In Replit, invite collaborators into the project or workspace and assign roles or groups controlling access. Builder seats and workspace role policies depend on plan. Builder seats and workspace role policies depend on plan. Requirement: Two people in the same project at the same time. Checked |
| Teams, workspaces & roles (Lovable's admin roles need a paid plan; Replit's team workspaces start at Core) | In Lovable, invite team members and set their roles. Admin roles require a paid plan. Sources: [110] Checked | In Replit, invite collaborators into the project or workspace and assign roles or groups controlling access. Builder seats and workspace role policies depend on plan. Builder seats and workspace role policies depend on plan. Requirement: Invite the team and control who can change what. Checked |
| A shared credit pool with per-member caps (Lovable's per-member caps come with paid admin roles; Replit's per-member limits are Enterprise-only)Different limits | Lovable: Team members share credits. Setting spending limits for each member requires paid admin roles. Sources: [112] Checked | In Replit Enterprise, an organization owner or admin can set per-user spend limits against shared usage. Per-user overrides take priority over group and workspace limits. Check which services and credits are covered. Enterprise plan and organization admin or owner permissions are required. Check which services and credits are covered. Per-user overrides take precedence over group and workspace defaults. Requirement: One pool the team draws on, with limits per person. Sources: [113] Checked |
| Official desktop app | Use Lovable’s native macOS or Windows desktop app for the web-builder experience plus local MCP access and project tabs. An internet connection is required for the agent. An internet connection is required for the agent. Requirement: Build from a real app, not just a tab. Sources: [114] Checked | Use the native Replit Desktop App on Windows, macOS or supported Debian-based Linux. The project environment and Agent still run in the cloud. The project environment and Agent still run in the cloud. Requirement: Build from a real app, not just a tab. Sources: [115] Checked |
| Security & compliance | ||
| A security scanner built into the builder (Lovable and Replit check security automatically at publish. Lovable's deep scan is free on every plan; Replit's deeper agent scans are for paid builders) | In Lovable, run the project security review and inspect findings covering data access, secrets and application code before publishing. Scan depth and scheduling depend on plan. A passing scan doesn't guarantee security. Scan depth and scheduling depend on plan; a passing scan does not guarantee security. Requirement: The platform checks your app for security weaknesses before someone else finds them. Checked | In Replit, open the Project Security Center to inspect dependency and application-code findings and use Agent to prepare fixes. Scan depth and availability depend on plan. A passing scan doesn't guarantee security. Scan depth and availability depend on plan; a passing scan does not guarantee security. Requirement: The platform checks your app for security weaknesses before someone else finds them. Sources: [118] [119] [120] [34] Checked |
| Two-factor authentication for your builder account | In Lovable, enable two-factor authentication in account settings on any plan. Sources: [121] (Lovable’s is a settings toggle on every plan. Replit documents MFA only through Enterprise SSO, so your identity provider enforces it, and no account-level toggle surfaced) Checked | Replit: The specific account-level second-factor setup remains unconfirmed. Requirement: A second step at login for the account that owns everything. Sources: [122] (Lovable’s is a settings toggle on every plan. Replit documents MFA only through Enterprise SSO, so your identity provider enforces it, and no account-level toggle surfaced) Checked |
| Enterprise SSO & SCIM provisioning (Lovable's SSO starts on Business and SCIM on Enterprise; Replit keeps both for Enterprise)Different limits | Lovable: Company sign-in starts on Business. Automatic account provisioning through SCIM requires Enterprise. Sources: [123] Checked | In Replit, configure Enterprise SAML SSO and SCIM to provision members and map identity-provider groups to workspace roles. Enterprise plan and account-level administrator access. App-user login is a separate capability. Enterprise plan and account-level administrator access; app-user login is a separate capability. Requirement: Your company's login, and accounts managed automatically. Checked |
| Fine-grained roles & permissions (Replit's custom groups are Enterprise-only; Lovable's granular control needs a paid plan) | Lovable: Granular control over who can access a project requires a paid plan. Sources: [110] Checked | In Replit, assign workspace roles and groups, then control access to individual projects. These are builder/project permissions, not a replacement for app-user data authorization. These are builder/project permissions, not a replacement for app-user data authorization. Requirement: Who sees what, down to the project. Checked |
| Control whether your work trains the models (Lovable’s opt-out is a free per-account toggle. Replit sets it by plan: paid endpoints don’t train, free-tier providers may, and no user toggle surfaced)Different limits | Lovable: A free account setting lets you exclude your prompts and code from model training. Sources: [128] Checked | In Replit, Pro users can opt out of Model Improvement in Settings → Personalization. Enterprise content is excluded by default. The opt-out applies to new content and doesn't delete earlier content. Pro is required for the account opt-out. Enterprise excludes customer content by default. The setting applies to new content and does not delete existing content. Requirement: Say no to your prompts and code becoming training data. Checked |
Follow the research
We gave Lovable and Replit the same Borrow Barn brief on 1 September 2026. We submitted borrow requests in both published apps, then opened their dashboards without signing in. Both dashboards showed the requests.
Our brief didn’t request authentication. Both dashboards stayed public in the test. That doesn’t mean Lovable or Replit is unable to protect a dashboard. These builds don’t establish long-term reliability or running costs.
The Borrow Barn recordings show what happened to our requests and who could read them. Terminal access, imports and mobile packaging use vendor documentation. Monitoring and editing findings also use linked sources. A matching checkmark doesn’t mean Lovable and Replit implement the capability the same way.
Checked September 1, 2026
Lovable picked the stack for you.
Earlier Lovable guidance described no terminal, existing-code imports or built-in store packaging. Current independent confirmation remains unavailable here. It builds web apps, with backend choices that include Lovable Cloud or connected Supabase. The 11 September finding says Lovable chooses the model used in Build and Plan mode.
fine if that’s how you want to build, and Lovable supports that way of building. If your project already exists, check Replit’s imports and your exact runtime before choosing.
You pay for what you run.
Agent work bills per effort-based checkpoint, hosting per compute unit, and the free plan’s one published app takes its link down after 30 days. What a build costs is knowable at the end. Ours was $1.06, and we knew when it finished.
Check the usage meter and account limits. Lovable has a fixed plan allowance, but neither starting price guarantees the full bill.
Lovable free won’t let you edit the code. The editor is read-only until $25. The app still builds, publishes and syncs to GitHub.
Lovable’s plan credits expire. Monthly credits expire two months after issue. A light month’s leftovers carry into the next month, no further.
Choose the app’s sign-in method on Replit. Replit Auth uses Replit accounts. Clerk Auth gives the app independent accounts, and Replit provisions it without a separate Clerk account. Configure the app’s access rules for either method.
Most Replit connectors need Core or higher. The 450+ directory is real, and the free tier keeps only the Replit-managed pieces: database, auth, storage.
Prices and usage allowances change. Each link opens the vendor’s live pricing page so you can check the current terms. The two “Start building free” buttons are affiliate links (disclosed below).
Readers who kept a Lovable or Replit app running know what the bill actually came to. Say what you paid once real users were on it, and whether you could take the code elsewhere when you tried.
Build visually or take the app’s code with you?
What does it cost to export your app’s code?
One product, read across every comparison.
All four, and the one question that splits them.