Glossary

Definitions of Lovable-specific terms, features, and the general web development concepts you’ll encounter in the documentation.

This glossary is split into two parts:

• Lovable terminology covers terms specific to the Lovable platform, its features, and how it works.
• General development concepts covers web, design, and backend terms that aren’t Lovable-specific but show up often in the docs.

Lovable terminology

Modes and how Lovable works

• Build mode: Lovable’s execution mode for implementing changes directly in your project. The agent writes code, runs tools, applies changes across files, and verifies the result. Use Build mode when you’re ready to ship a change. (Previously called Agent mode.)
• Plan mode: Lovable’s reasoning and brainstorming mode. Use it to explore ideas, compare approaches, investigate issues, and review or edit a plan before any code changes. Plan mode never modifies your project.
• Subagents: Temporary, read-only agents that Lovable spins up to research, inspect, or review focused parts of a task in parallel. Subagents report findings back to the main agent but cannot change your project.
• Prompt: A natural-language instruction you send to Lovable to create, modify, debug, or explain something in your app.
• Prompt queue: A queue of prompts you can send while Lovable is already working. Queued prompts can be reordered, edited, paused, or removed before they run.
• Diff: A side-by-side comparison of file changes Lovable made in a turn.
• History: The chronological log of changes to your project. Lets you revert to a previous version or bookmark important checkpoints.
• Visible tasks: The step-by-step progress view that shows what Lovable is doing during a Build mode run, including which files it’s touching.

Workspace, projects, and people

• Workspace: The shared space where a group of people builds together. It holds your projects, members, billing, and settings, and everyone you invite builds from the workspace’s shared plan and credits, each on as many of their own projects as they want. Every project lives inside a workspace.
• Workspace admin settings: The central place where workspace owners and admins configure identity, access, templates, billing, domains, security, and developer settings for the workspace.
• Project: A single Lovable app, with its own code, chat history, integrations, and settings. Projects always belong to a workspace.
• External collaborator: Someone outside your workspace who has been granted access to a specific project. External collaborators don’t have a seat in the workspace itself.
• Project access (project visibility): The setting that controls who can open and edit a project in the Lovable editor: Workspace or Restricted (Business and Enterprise).
• Restricted project: A project visible only to people explicitly added to it, even within the workspace. Available on Business and Enterprise plans.
• Share dialog: The dialog where you invite people or groups to a project, manage roles, and copy invite links.
• Groups: Named collections of workspace members used to grant access to projects, folders, and published apps in bulk. Groups can also sync from your identity provider via SCIM. Available on Business and Enterprise plans.
• SSO (Single sign-on): Workspace-level authentication through your identity provider (Okta, Microsoft Entra ID, Auth0, Google Workspace) using OIDC or SAML.
• SCIM provisioning: A connection that automatically creates, updates, and removes workspace users, and syncs groups, from your identity provider.
• Audit logs: A searchable trail of workspace activity showing who did what, when, and to which resource. Enterprise plans.

Building and editing

• Preview: The live, interactive view of your app inside Lovable. The preview updates as Lovable builds, and you can interact with it the same way an end user would.
• Preview toolbar: The toolbar on top of the preview that lets you select elements, edit text inline, draw annotations, and leave comments without leaving the preview. Replaces the older Visual edits panel.
• Code editor: The in-Lovable view for browsing and manually editing your project’s source code. Editing is available on paid plans. See the code editor. (Sometimes called Code mode.)
• Knowledge: Persistent instructions Lovable remembers across conversations. Split into workspace knowledge (rules and standards that apply to every project in the workspace) and project knowledge (project-specific context, personas, conventions, and design notes).
• Skills: Reusable, named playbooks defined at the workspace level. Each skill packages markdown instructions that Lovable applies whenever a matching task comes up, either invoked with a / command or triggered automatically.
• Cross-project referencing: A way to pull code, assets, files, or chat history from another project in your workspace using @ mentions, so you can reuse implementations without rebuilding them.
• File generation: Lovable’s ability to analyze data and produce downloadable files (CSV, PDF, Excel, charts) directly in the chat, without modifying your project’s source code.
• Browser testing: A testing tool where Lovable drives your app in a real browser, clicking, filling forms, and capturing screenshots, to verify user flows end to end.
• Testing tools: The umbrella feature covering browser testing, frontend tests (Vitest + React Testing Library), and edge tests (Deno test runner for edge functions).
• Remix: A copy of a project’s current state used as the starting point for a new one, edited independently while the original is preserved. You can remix one of your own projects, any project you have access to, or another user’s project that has public remixing enabled.

Design

• Design guidance: The pre-build step where Lovable either shows three lightweight design directions to compare, asks design questions about typography, color, and layout, or builds directly when the visual intent is already clear.
• Design directions: Three side-by-side HTML and Tailwind previews Lovable can generate before a build, so you can pick a visual direction before committing.
• Design systems: An Enterprise-only feature for defining a reusable React component library, styling guidelines, and setup instructions in a dedicated Lovable project. Other projects in the workspace can connect to that design system and receive updates.
• Design templates: Approved Lovable projects marked as reusable. Starting a new project from a template copies the full codebase, including structure, components, configuration, and styling. Available on Business and Enterprise plans.

Publishing, hosting, and domains

• Hosting: Lovable serving your published app for you: a public URL, automatic HTTPS, and delivery from locations around the world, with no servers to set up.
• Publish: The action that puts your project on a public URL. Publishing creates a snapshot; later edits require republishing to go live.
• Website access: The setting that controls who can visit your published app. Options include public, workspace only, or a custom audience of groups, members, and people outside the workspace invited by email (Business and above).
• Custom domain: A domain you own (e.g. yoursite.com) connected to a published Lovable project. You can connect a domain from another registrar or buy one through Lovable.
• Transfer a domain: The process of moving a domain you already own from another registrar into Lovable, so Lovable becomes the registrar.
• Branded app URLs: A workspace-level subdomain that replaces the default your-app.lovable.app with {app-name}.{workspace-subdomain}.lovable.app for every app in the workspace. Available on Business and Enterprise plans.
• Analytics: Built-in traffic and engagement metrics for published projects.
• SEO and AI search (AEO): The combined tab for Search Engine Optimization and Answer Engine Optimization. Includes on-demand SEO reviews, sitemap/robots/llms.txt checks, Lighthouse performance, Semrush keyword research, and Google Search Console setup.

Hosting and built-in backend (Cloud)

• Lovable Cloud: Lovable hosts your app and includes a built-in backend with database, storage, authentication, realtime, and functions, all with no external setup.
• Database: Your app’s organized data store, where records such as users, orders, and messages live in tables. The Database view lets you browse those tables, edit records, run SQL, and restore daily backups.
• Storage: Buckets holding your app’s uploaded files, such as photos and documents. Private by default, with signed URLs for sharing.
• Jobs: Scheduled background tasks in your app’s backend, such as a daily summary email, with a run history. Created by prompting Lovable.
• Logs: A searchable record of everything your app’s backend does, across functions, database, auth, and storage. Where debugging starts.
• Project usage: The view showing what a project’s hosting and backend usage costs, credit by credit, broken down by category.
• Advanced settings (Cloud): The settings for the machinery behind a project’s backend: instance size, disk space, data export, and pausing or removing it.
• Edge functions: Small programs that run your app’s behind-the-scenes logic on Lovable’s servers, such as processing payments, calling other services, or handling webhooks.
• Secrets: Securely stored API keys, tokens, and credentials, made available to your backend code so they never appear in the browser.
• Email auth: Sign-in with an email address and password or one-time codes, with configurable confirmation and password rules. The default sign-in method for Cloud apps.
• Phone auth: Sign-in with a phone number and an SMS one-time code, using your own SMS provider.
• Google auth: Sign in with Google for your app’s users, using Lovable-managed OAuth or your own Google Cloud credentials.
• Apple auth: Sign in with Apple for your app’s users, using Lovable-managed OAuth or your own Apple Developer credentials.
• SAML SSO (apps): App-level single sign-on that lets your app’s end users sign in with their company identity provider (Okta, Entra ID, Google Workspace, OneLogin, JumpCloud, or any SAML 2.0 IdP). Configured per project. Different from workspace SSO.
• Lovable workspace identity reuse (apps): A feature that lets apps built in the workspace recognize the signed-in workspace member automatically, with no separate login flow. Business and Enterprise plans. Different from workspace SSO and from SAML SSO for Cloud apps.
• Custom emails: Authentication and app emails sent from your own domain, with automatic SPF, DKIM, and DMARC setup to improve deliverability.
• Payments: Built-in subscriptions and one-time payments powered by Paddle or Stripe.

Security

• Security overview: The umbrella for Lovable’s built-in security: Basic and Deep scans, API key protection, RLS checks, dependency audits, and optional security connectors.
• Basic scan: A fast configuration and dependency check that runs locally inside Lovable. Free, doesn’t consume credits.
• Deep scan: A more detailed, agentic code review for harder-to-detect vulnerabilities. Free, doesn’t consume credits.
• Security view: Per-project tab showing scan results, dependency findings, and security recommendations.
• Security center: Workspace-level dashboard that aggregates security findings, scan coverage, scheduled scans, secrets, and dependency risks across every project. Business and Enterprise plans.
• Workspace insights: Portfolio view in the Security center that combines security findings, PII, ownership, lifecycle, publish status, and activity into a single review priority per project. Enterprise plan.
• Privacy & security settings: Workspace-wide controls for default project access, publishing permissions, MCP access, sensitive data scanning, and data protection.
• Data opt-out (training data and privacy): Enterprise option to exclude your workspace’s data from being used for AI training.

Integrations

• App + chat connectors: A connection type that runs on one shared account and works in two places: Lovable uses it in the chat while you build, and your published app uses it while people use the app. Created once per workspace and linked to the projects that need it.
• App user connectors: A connection type where each end user of your published app connects their own account (for example their own Gmail or Salesforce), so the app acts with that user’s permissions and sees only their data.
• Chat connectors (MCP servers): A personal connection to one of your own tool accounts, such as Notion, Linear, Jira, Confluence, or Miro, built on the Model Context Protocol. Gives Lovable real context from that tool in the chat while you build, and is never part of the published app.
• Lovable MCP server: An MCP server that lets external AI agents and developer tools (ChatGPT, Claude Desktop, Cursor) build, iterate on, and deploy Lovable apps programmatically.
• Lovable AI: Built-in AI models you can use inside the apps you publish, for chatbots, summaries, sentiment detection, image generation, semantic search, and more. No API keys required.
• Build with URL: A way to create Lovable apps from a URL by passing prompts and images as parameters. Useful for embedding “Build with Lovable” buttons or automating app generation.
• Lovable desktop app: A native app for macOS and Windows with multi-tab project management, local MCP support (Figma, Paper), and keyboard shortcuts.
• Lovable mobile app: The mobile companion app for building and reviewing Lovable projects on the go.
• Supabase: Open-source backend-as-a-service. Can be connected to Lovable projects as an alternative to the built-in backend (Cloud).
• Git sync: Two-way sync between a Lovable project and a Git repository, for version control, code review, and developer collaboration. Works with GitHub and GitLab.
• GitHub integration: Git sync with a GitHub repository.
• GitLab integration: Git sync with a GitLab project.

Plans, credits, and billing

• Credits: Units Lovable uses to measure and pay for credit-based usage across your workspace. Credits can be used for building your app, hosting it and running its built-in backend (Cloud), and powering AI features in deployed apps.
• Credit top-up: An optional purchase of additional credits available on Pro and Business plans, separate from your monthly subscription. Top-ups can be purchased manually as a one-time top-up or automatically with auto top-up.
• Daily build credits: Credits granted every day on Free, Pro, and Business plans for Build usage only. Free, Pro, and Business plans include 5 daily build credits that reset every day at 00:00 UTC and do not roll over. Free daily build credits are capped at 30 per calendar month. Pro and Business daily build credits do not have a monthly cap.
• Usage-specific grants: Included credits that apply only to one type of usage, such as daily build credits, the monthly Cloud grant, or the monthly AI grant. Usage-specific grants are used before general credits and do not roll over. Daily build credits reset every day at 00:00 UTC. On Free plans, monthly Cloud and AI grants reset on the 1st of each calendar month at 00:00 UTC. On Pro and Business plans, monthly Cloud and AI grants refresh with the subscription billing cycle.
• General credits: Credits that can be used after usage-specific grants run out to build your app, host your app and run its built-in backend (Cloud), and power AI features in deployed apps. General credits include monthly plan credits, top-up credits, and bonus credits.

See Credits and usage for more information.

General development concepts

These terms are not Lovable-specific. They come up across web, design, and backend development and are included here as a reference when you see them in the docs.

Frontend and UI

• Frontend: The part of an app users see and interact with in the browser.
• React: The JavaScript library Lovable uses to build user interfaces.
• Tailwind CSS: The utility-first CSS framework used to style Lovable projects.
• Component: A reusable piece of UI (button, card, form, navbar) that combines to build pages.
• Responsive design: Layouts that adapt to different screen sizes such as mobile, tablet, and desktop.
• Hero section: The prominent area at the top of a landing page, typically containing a headline, subheading, and call to action.
• CTA (Call to action): A button or link prompting users to take an action, such as “Sign up”, “Get started”, or “Buy now”.
• Modal / Dialog: An overlay window that interrupts the main flow to capture attention or input.
• Toast: A brief, non-intrusive notification that appears temporarily.
• Tooltip: A small popup that appears on hover or focus to provide extra information.
• Skeleton loader: A placeholder UI that mimics the final layout while real content is loading.
• Above the fold: The portion of a page visible without scrolling.
• Breadcrumb: A navigational element showing a user’s location within the site hierarchy.
• Favicon: The small icon shown in browser tabs and bookmarks.

Design language and styles

Use these terms in prompts to steer Lovable toward a specific aesthetic.

• Glassmorphism: Translucent, frosted glass elements with blur and subtle borders.
• Neobrutalism: Bold, raw, high-contrast design with unpolished edges and chunky typography.
• Minimal: Clean layouts, lots of whitespace, restrained color and type.
• Premium: Refined, sophisticated, attention-to-detail aesthetic.
• Retro: Visual styles borrowed from past decades, such as neon, pixel, or vintage.

Backend, databases, and APIs

• Backend: The behind-the-scenes part of an app, where data is stored, rules are enforced, and users are signed in. The frontend is what users see; the backend is what makes it work.
• Database: Organized storage for an app’s data, holding records such as users, products, or messages in a structured way the app can read and update. Lovable apps use a relational (table-based) database.
• API (Application Programming Interface): A way for two software systems to talk to each other. An API defines what one system can ask another for, and what answers to expect.
• REST API: The most common API style. It uses standard web requests (GET to read, POST to create, PUT to update, DELETE to remove) at predictable URLs.
• Endpoint: A specific URL on an API where your app sends or receives one kind of data, such as /customers for customer records.
• Webhook: A notification an external service sends to your app when something happens there, such as Stripe telling your app that a payment succeeded.
• CRUD (Create, Read, Update, Delete): The four basic things an app does with data. A contact manager is CRUD at work: add a contact, view it, edit it, remove it.
• SQL (Structured Query Language): The language used to work with relational databases. Lovable writes SQL for you, and you can run your own queries in the SQL editor.
• PostgreSQL: The open-source database that powers the built-in backend (Cloud) and Supabase, and where your app’s data lives.
• RLS (Row-level security): Rules that decide which rows of data each user can see or change, for example “users can only read their own orders”. Essential for multi-user apps. Review yours in the RLS policies view.
• Bucket: A folder-like container for files (images, videos, documents) in storage.

Authentication and security

• OAuth: A protocol that lets users log in to your app using a third-party account (Google, GitHub, etc.) without sharing their password.
• SAML 2.0: An XML-based standard for enterprise single sign-on between an identity provider and a service provider.
• OIDC (OpenID Connect): A modern authentication layer on top of OAuth 2.0, commonly used for SSO.
• IdP (Identity provider): A service that authenticates users, such as Okta, Microsoft Entra ID, Google Workspace, Auth0, JumpCloud, or OneLogin.
• 2FA (Two-factor authentication): A second verification step in addition to a password.
• CORS (Cross-Origin Resource Sharing): A browser security policy that controls which origins can call your API.

SEO and discoverability

• SEO (Search Engine Optimization): Optimizing a site to rank in traditional search engines like Google or Bing.
• AEO (Answer Engine Optimization): Optimizing a site so AI search engines like ChatGPT, Perplexity, Claude, or Gemini surface it as an answer.
• Meta title / Meta description: The page title and short summary shown in search results.
• Canonical URL: The preferred URL for a page, used to avoid duplicate-content issues.
• Sitemap: An XML file listing a site’s pages to help search engines crawl them.
• robots.txt: A file telling crawlers which paths they can or can’t access.
• llms.txt: A newer convention for guiding AI crawlers about a site’s content and policies.
• Open Graph: Meta tags that control how a page is previewed when shared on social platforms.
• Lighthouse: Google’s open-source auditing tool for performance, accessibility, SEO, and best practices.

Design and asset resources

External tools and libraries commonly used with Lovable.

• 21st.dev: Open-source React UI components powered by Tailwind CSS and Radix UI.
• Google Fonts: Free, web-optimized font library.
• SVG Repo: Open-licensed SVG icons and graphics.
• Dribbble: Designer community for visual inspiration.
• Noun Project: Library of free icons and stock imagery.
• Typewolf: Curated font pairings and typography inspiration.