Getting started with Lovable

Lovable is a prompt-based app builder: you describe what you want, and Lovable generates a full web app with a live preview (React + TypeScript + Vite + Tailwind under the hood). This guide walks you through your first project, from account to publishing.

Want to try it yourself right away? Start for free with Lovable. As the Lovable partner in the Brainport region (Eindhoven, NL), we're also here if you'd rather bring in a developer directly — see below on when that makes sense.

Creating an account and starting your first project

Sign up at lovable.dev and start a new project from a blank prompt or a template. Describe in your first message what you want to build: what the app does, who it's for, and which main pages or components you expect. The more concrete your first prompt, the fewer correction rounds you'll need.

A solid first message includes:

• The goal of the app or website
• The main pages/screens
• Any data sources (static or dynamic)
• Style preference (e.g. clean and professional, or playful)

How chat and preview work

Lovable works with a chat panel on one side and a live preview on the other. You type an instruction, Lovable updates the code, and the preview refreshes automatically. You see changes immediately, without building or deploying anything yourself.

Below the preview (or in a separate tab) you'll find console and network logs. These become essential once you start debugging: an error in the console usually points you straight to what went wrong.

Plan mode: think before you build

For bigger features, it's smart to work in plan mode instead of building directly. You describe what you want, Lovable proposes an approach (which pages, components and logic will be added), and you can adjust that plan before any code is generated. This prevents you from having to undo a large change because the approach didn't fit.

Use plan mode especially for:

• New features that touch multiple pages
• Changes to data models or database structure
• Anything where you're still unsure about the best approach

Work in small steps

Lovable's own documentation advises breaking large changes into smaller steps. Don't ask in one prompt for "a complete webshop with checkout, customer accounts and a dashboard" — split it into separate, manageable instructions. Benefits:

• You can check each step before moving on
• Errors stay local and are easier to trace
• Rollback (see below) is more precise when steps are small

Versions and rollback

Every change Lovable makes is recorded as a version. If a step went the wrong way, you can go back to an earlier version without manually restoring code. This is another reason to work in small steps: the smaller the step, the more precisely you can roll back without losing good changes too.

Lovable Cloud: database, auth and more

Once your app needs more than static content — user accounts, a database, file storage or server functions — you turn on Lovable Cloud. Cloud runs on a Supabase base and handles:

Component	What it does
Database	Storage for your data, in tables you manage via prompts or the Cloud tab
Auth	User sign-up and login
Storage	Files and media
Server functions	Logic that shouldn't run in the browser
Lovable Email	Transactional and auth emails from your own domain (requires Cloud)

You can export data via Cloud tab → Advanced settings → Export data. If your project starts hitting performance limits as it grows, you can choose a larger instance under Cloud → Overview → Advanced settings (this costs more credits/money).

Note: "vibe coding" — building quickly from prompts — comes with real considerations around security and maintainability. Set up authorization (RLS) properly, test critical flows, and have sensitive parts reviewed before going live.

Publishing and connecting a custom domain

With one click you publish your project to a lovable.app subdomain. Want to go live under your own domain? Connect a custom domain to the project. This lets a small team ship a working version quickly without arranging separate hosting.

Git sync with GitHub (and GitLab)

Lovable supports git sync with GitHub and GitLab, available on all plans, including Free. This means your project is always also available as a regular git repository — handy if you later want a developer to review it, or want to keep developing outside Lovable.

Downloading code

Want to run the source code locally or manage it outside Lovable? You can download it — this is available from the Pro plan onward (not on Free). Projects and code always remain owned by you as the user, regardless of plan.

Collaborating on a project

Multiple team members can work on the same project: one writes prompts for content, another for functionality. Combine this with git sync if you also want to collaborate with a developer outside Lovable, and with plan mode to align before someone pushes a large change.

When to bring in a developer

Lovable is powerful for prototypes, MVPs and even full products, but there are moments where professional help is worth the investment:

• Your project touches sensitive data and you want certainty about authorization and security
• Performance starts hitting limits as you grow
• You want an architecture ready for scale, integrations or more complex logic
• You want an external review before going live

As the Lovable partner in the Brainport region (Eindhoven), we help teams who started with Lovable and want to scale up, professionalize, or get an external check on their project. Also check our pages on web design and websites, or get in touch for an advisory call.

Checklist for your first project

• Account created and first prompt written with goal, audience and main pages
• Used plan mode for the first bigger feature
• Worked in small steps, checking the preview each time
• Turned on Lovable Cloud once you needed a database or login
• Set up git sync with GitHub
• Published and (if needed) connected a custom domain
• Considered an external review if in doubt about security or scale

Common mistakes new users make

• Asking for too much in one prompt — leads to unpredictable results and hard-to-trace errors.
• Skipping plan mode for big features — you end up building something that needs reworking anyway.
• Forgetting rollback exists — not knowing you can easily go back to an earlier version, so people start "fixing" things manually instead.
• Ignoring Cloud settings — no attention to authorization/RLS for sensitive data.
• Never checking the console logs — the fastest way to understand an error is to read the error message itself.
• Skipping the custom domain — going live on the lovable.app subdomain when your own domain looks more professional and helps with brand building.

Frequently asked questions

Do I need technical knowledge to get started with Lovable?

No, you can prompt in natural language. For more complex projects (authorization, performance, integrations) it helps to have technical review somewhere in the process.

Can I still switch to a developer later?

Yes. Thanks to git sync with GitHub, your project is always also available as a regular codebase, and from Pro onward you can also download the code.

What does Lovable cost?

There's a free plan with daily build credits, and paid plans with more credits and features like code download. Check lovable.dev/pricing for current rates, or read our explainer on Lovable pricing.

Do I always need to turn on Lovable Cloud?

No, only if you need a database, user accounts, file storage or server functions. A simple content website can run without Cloud.