Insights / October 20, 2026

Lovable Cloud pricing: what drives your bill, and how to cut it

Lovable Cloud is a big part of why Lovable is so fast. You get a database, sign-in, file storage and server functions without setting anything up. The catch is that it’s usage-based, and the bill grows with your app in ways that are hard to see from inside the editor.

We recently looked after a Lovable app whose running costs had become the founder’s biggest worry. Here’s how the billing works, what was actually driving it, and what we changed.

How Lovable Cloud billing works

Lovable now uses one credit balance for both building and running your apps. Every Free, Pro and Business workspace gets 20 credits a month for Cloud services. After that, the running app draws from the same credits you use to build.

What counts as running the app: the database, authentication, file storage, server functions and any AI calls your app makes. The billing page, now called Plans & credit usage, breaks spending down by project and by building versus running.

Lovable doesn’t publish a simple price list per service, and plans change, so check Lovable’s pricing page for current numbers. What matters more is knowing which parts of your app use the credits, because that’s what you can change.

Where the money actually went

The app was a media delivery platform: creators upload photos and video, and their clients view and download them. Over two weeks, its running costs split like this:

What Share of running costs
Realtime (live updates) 45%
Network (data sent to browsers) 41%
Database 11%
Storage 2%
AI under 1%

Most founders guess the database or AI is the expensive part. Here they were a small slice. The two biggest lines were things nobody had decided to pay for.

1. Realtime: live updates nobody was watching

Lovable apps often use live updates: the page changes the moment something changes in the database, with no refresh. It feels great in a demo. Every one of those updates is a message you pay for.

In this app, every open dashboard page was listening to every change to every file the creator owned, across all their projects. Behind the scenes, dozens of background jobs were updating those files around the clock: processing video, creating thumbnails, retrying failed steps. Each change was pushed to every open tab, and each tab then reloaded its whole page of files.

It got worse in two ways:

  • Nothing stopped listening. Creators leave dashboards open for days in background tabs.
  • Older versions of the mobile app listened to every change in the entire database, for every customer, not just their own. Phones that never updated kept doing it.

What we changed:

  • Polling where instant didn’t matter. The download page used live updates to show a ZIP being built, one message per file. It now checks every 15 seconds while a build is running, and stops when it’s done.
  • Narrow, cheap updates where it did. The dashboard now gets a tiny message only when one of that page’s files changes status, and refreshes just that tile.
  • Switching off live updates for tables nothing listens to. Once the current web and app code no longer needed them, we turned them off on the server. That stopped the old app versions too, which still work but refresh a little less instantly.

2. Network: data taking the long way round

Network is the data your app sends out: pages, images, API responses, downloads. For a media app some of it is unavoidable. But two things inflated it:

  • Downloads passing through server functions instead of coming straight from storage.
  • The same work done repeatedly, such as large downloads being rebuilt when an old link was opened.

Serving files directly from storage, and only rebuilding when something actually changed, is usually the biggest network saving.

3. Database and background jobs

The database was only 11% here, but two things are worth checking in any Lovable app:

  • Server size. The database runs on an instance you choose, billed for as long as it runs. Bigger isn’t automatically better.
  • Background jobs that write the same rows over and over. We found a job that was supposed to mark broken records so it would skip them next time. The mark it used matched its own search, so it picked up and rewrote the same records every 30 minutes. Each pointless write also fired live updates.

The result

About 90%. That’s how much these changes cut the Realtime line, the largest part of the bill.

How to check your own Lovable Cloud costs

  1. Open Plans & credit usage and look at your project’s running costs by category. Find the biggest line before changing anything.
  2. If Realtime is high, search your code for .channel( and postgres_changes. For each one, ask: does this need to be instant? Does it listen to more than the page shows? Does it keep running in a background tab?
  3. If Network is high, look for files or downloads that go through server functions instead of straight from storage.
  4. Check your scheduled jobs. Any job that runs every few minutes and updates rows deserves a look at what it updates and why.
  5. Set a spending limit in your billing settings while you investigate, rather than turning off top-ups. Running out of credits can take your app offline.

You can also ask Lovable in your project chat what’s driving your running costs. It’s a good first pass, but it can’t weigh which live updates your users actually need.

If your Lovable Cloud bill is growing faster than your users, our Lovable rescue starts with exactly this: finding what you’re paying for, and cutting what nobody needs.

LET’S TALK.

Book a free 30-minute call with Virgil

Pick a time that suits you. You’ll get a straight answer on what you need, what it should cost and the fastest path to launch.

Loading available times…

Open the calendar in a new tab

Send us your project

Virgil replies personally within one business day.

Book a free strategy call