The cheapest database for a small app in 2026, with real prices

Prices are list prices read from each vendor's official pricing page on 4 November 2026, in USD, before tax.

TL;DR

• The problem: you need a database that won't surprise you with a bill or fall asleep while users wait.
• What you get: the real monthly cost of a small database on Turso, Neon, Supabase and Hubfly space, for three app sizes, with every formula shown.
• Who it's for: anyone choosing a database for a side project, an MVP or a small production app.
• Time needed: 10 minutes to read, 2 minutes to pick.
• Short answer: for a hobby project that sleeps, a free tier wins (Turso, Neon or Supabase, $0). For a small app that must stay on all day, a dedicated Hubfly space instance costs $1.92–$3.86 a month, against $5.99 on Turso, about $21 on Neon and $25 on Supabase. The catch on Hubfly space: no free tier for managed databases and no automatic backups yet.

Your app needs a database, and every "best free database" list you find was written months ago. Free tiers have changed, Turso has announced it is joining Supabase, and the real question isn't "what's free?" but "what will I pay the day my app gets real users?" Pick wrong and you either get a surprise bill or a database that falls asleep while a customer is waiting.

This guide prices the same three apps on four platforms, tells you what happens when you outgrow each free tier, and says plainly where each one wins.

Try a database on Hubfly space

The cheapest managed database options in one paragraph each

Turso is hosted SQLite (libSQL). You pay for storage and rows read and written, not for CPU time, and you can have hundreds of databases. Turso's site now carries the banner "Turso is joining Supabase", so expect changes over the next year (Turso pricing).

Neon is serverless Postgres. Compute is billed per CU-hour and scales to zero after 5 minutes idle, so a quiet database costs almost nothing. You get instant branches for previews and tests (Neon pricing).

Supabase is Postgres plus a full backend: auth, file storage, realtime and edge functions. The Pro plan is a flat $25 with a $10 compute credit (Supabase pricing).

Hubfly space runs a dedicated, always-on PostgreSQL, MySQL or SQLite (libSQL) instance for you, billed per hour from the same CPU, memory and storage rates as its containers, plus a 30% management fee (Hubfly space databases).

Price table (4 November 2026)

Three apps, four bills

Free tiers are easy to compare. What matters is the bill once the app is real. Here are three typical cases, priced at list prices, with 730 hours in a month.

1. A side project: 400 MB of data, busy up to 12 hours a day

Winner: any free tier. If your project can tolerate sleeping, don't pay for a database yet.

2. A small production app: 5 GB, about 1 GB of RAM, on 24/7

This is the app with paying users, where "it was asleep" is not an excuse.

If 512 MiB of memory is enough, Hubfly space Nano with 5 GiB is $1.97.

3. A growing app: 20 GB, about 2 GB of RAM, on 24/7

The Hubfly space math, line by line

Rates: CPU $0.004 per vCPU-hour, RAM $0.002 per GB-hour, storage $0.00001536 per GB-hour, 730 hours a month. Each instance also has a 1 GiB system disk billed at the storage rate, and a 30% management fee on CPU and RAM while it runs.

• Nano, 1 GiB: compute (0.25 × 0.004 + 0.5 × 0.002 + 1 × 0.00001536) × 730 = $1.47; management 0.3 × 0.002 × 730 = $0.44; storage 1 × 0.00001536 × 730 = $0.01. Total $1.92.
• Small, 5 GiB: compute (0.5 × 0.004 + 1 × 0.002 + 0.00001536) × 730 = $2.93; management 0.3 × 0.004 × 730 = $0.88; storage 5 × 0.00001536 × 730 = $0.06. Total $3.86.
• Medium, 20 GiB: compute (1 × 0.004 + 2 × 0.002 + 0.00001536) × 730 = $5.85; management 0.3 × 0.008 × 730 = $1.75; storage 20 × 0.00001536 × 730 = $0.22. Total $7.83 (parts rounded).

Why the numbers are so different

The four platforms bill for different things, and that decides who wins.

• Neon bills compute time. That's ideal for a database that's idle 20 hours a day and expensive for one that's busy all day. Turn scale to zero off and the meter runs 730 hours.
• Supabase bills a plan. $25 buys you auth, storage, realtime and backups as well. If you use those, the database is almost free. If you only need Postgres, you pay for things you don't use.
• Turso bills rows. Idle databases cost only storage, and compute is never on the bill. A query that scans a large table counts every row it reads, so a missing index shows up as cost.
• Hubfly space bills dedicated capacity. You get a fixed slice of CPU and memory that's always on, at container rates. It doesn't sleep, so it doesn't wake up slowly, but it also never drops to $0.

What happens when you outgrow the free tier

This is where most lists stop, and where most surprises start.

• Turso Free: when you hit a limit you need to upgrade. On paid plans with overages off, databases are blocked at the limit; with overages on, you pay per unit (Turso pricing FAQ).
• Neon Free: if a project uses its 100 CU-hours or 5 GB of transfer, its compute is suspended until the next month. Over 1 GB of storage, writes that grow the database fail. Neon says none of this deletes data (Neon pricing FAQ).
• Supabase Free: a project with no activity for a week is paused, and you can have 2 active free projects (Supabase pricing).
• Hubfly space: there's no free tier to outgrow. Billing runs from your balance from the first hour. To avoid surprises, set a monthly budget cap on the project. At 100% its running workloads are stopped and new starts are blocked, and you get emails at 80% and 90% first.

Switching between Turso and Hubfly space: same client, new URL

Both run libSQL. Hubfly space's SQLite (libSQL) instances give you a libsql:// URL and an access token, and the Connect page shows the same @libsql/client code Turso documents for remote libSQL databases (Turso TypeScript quickstart):

import { createClient } from "@libsql/client"; const db = createClient({ url: process.env.LIBSQL_URL!, // the libsql:// URL from the Connect page authToken: process.env.LIBSQL_AUTH_TOKEN!, }); const rows = await db.execute("select 1"); 

If your app already uses @libsql/client with Turso, moving means changing those two environment variables and copying your data. Exports aren't available on new Hubfly space SQLite instances yet, so plan the copy as a script that reads from the old database and writes to the new one through the same client. Apps built on Turso's newer @tursodatabase/* packages need the compat import or a switch to @libsql/client first.

How to set up the cheapest always-on option on Hubfly space

1. Open the dashboard, click Create Project, choose Managed service and create the project.
2. Click Create a database. Pick PostgreSQL (or SQLite (libSQL) if your app already speaks libSQL).
3. Choose Nano or Small, and set Storage to what you need. You can grow it later, but never shrink it.
4. Under Network & access, public access is on by default. Click Add my IP and add your server's address; an empty allowlist means any IP can connect.
5. Name it something like orders-db and click Create database. It's ready in a minute or two. A first CREATE TABLE, INSERT and SELECT in the SQL editor run in well under a second.
6. Copy the connection string from Connect into your app's environment variables.

Need to pause it? Click Stop. Stopping and starting each take a minute or two, your data is still there afterwards, and while it's stopped you pay only for storage ($0.01 a month for 1 GiB).

Why the allowlist matters: a database that's open to every IP depends only on its password or token. Limiting it to your app's addresses means a leaked credential alone isn't enough.

Backups: the part you must not skip

Hubfly space shows Automatic backups: Coming soon, and the SQL editor in write mode warns: "Writes change your data immediately. There are no backups." Until scheduled backups ship, back up yourself. For PostgreSQL, run this from a machine whose pg_dump version is the same as or newer than your server (PostgreSQL 18 by default):

pg_dump --format=custom --no-owner --no-acl "$DATABASE_URL" -f orders-db-$(date +%F).dump 

To restore into a fresh instance:

pg_restore --no-owner --no-acl -d "$DATABASE_URL" orders-db-2026-11-03.dump 

Use a pg_restore at least as new as the pg_dump that made the file.

If your dump uses extensions such as vector or postgis, install them first from the instance's Extensions tab. Run the backup on a schedule and copy the file to Hubfly space Storage or another bucket. A backup that lives on the same instance isn't a backup.

If built-in backups and point-in-time restore matter more than price today, Turso (10 days on Developer), Neon (up to 7 days on Launch) and Supabase Pro (daily, kept 7 days) are ahead.

Where each one wins

• Pick Neon if your database is idle most of the day, or you want a branch per pull request. Scale to zero and branching are its real strengths, and the free tier is generous.
• Pick Supabase if you also need auth, file storage and realtime. The $25 covers a whole backend, with daily backups included.
• Pick Turso if you want many small SQLite databases (one per user or per agent), or the lowest flat price with point-in-time restore included. Watch your row counts.
• Pick Hubfly space if your app must be on 24/7 and you want the lowest predictable bill: $1.92–$7.83 a month for dedicated Postgres or SQLite (MySQL from $3.82), next to your app. Plan your own backups for now.

What can go wrong

1. "My free database stopped answering." Neon suspends compute after 100 CU-hours in a month, Supabase pauses projects after a quiet week, and Turso archives free databases after 10 quiet days. Fix: upgrade, or wake it (Turso: turso group unarchive <group-name>) and add a scheduled health check if the app needs to stay reachable.
2. "My Neon bill is four times what I expected." Scale to zero was turned off, or something pings the database every few minutes so it never sleeps. Fix: find the caller (health checks and cron jobs are the usual suspects), or cap compute with autoscaling limits.
3. "My Hubfly space database stopped at the end of the month." A budget cap at 100% stops running workloads, including the database. Fix: act on the 80% and 90% emails and raise the cap before it hits.
4. "I can't connect to my Hubfly space database." Check the port and host on the Connect page (managed Postgres doesn't use 5432), and make sure your app's IP is on the allowlist if you set one. Connections need TLS (sslmode=require for Postgres).

The takeaway

Free tiers are for projects that can sleep. The moment your database has to stay awake, the cheapest bill comes from paying for a small, always-on slice of a server, not for compute time. For a 5 GB production app that's $3.86 on Hubfly space, $5.99 on Turso, about $21 on Neon and $25 on Supabase. Choose with your eyes open: the cheapest option today is also the one where backups are your job.

Go further on Hubfly space

• Run your app next to it. Deploy the app itself as a container on Hubfly space Cell and keep the whole bill in one place (deploy docs).
• Set up Postgres step by step. If you've settled on PostgreSQL, read How to get a managed PostgreSQL database for about $2 a month.
• Store your backups. Put nightly pg_dump files in a Hubfly space Storage bucket at $0.011 per GB-month (Storage docs).
• Cap your spend. Set a monthly budget on the project so a runaway month can't surprise you (pricing).

Moving from another provider? Create your first database on Hubfly space and price your exact size in the live estimate before you click Create.