Expert Guide

The Best Backend-as-a-Service Platforms in 2026

The database and the meter decide the backend in 2026. An organization plan, a per-developer plan, and a peak-requests plan can share a sticker and still be different purchases.

Product links may be affiliate links. How we rate 9 tools compared
TL;DR

Supabase is the backend most web teams should start on in 2026: Pro is $25/mo per organization, the database is Postgres, and auth, storage, and edge functions come with it. Firebase is the pick when the client is a phone and offline sync matters.

Appwrite Pro, Nhost Pro, and Convex Professional publish that same entry rate on different meters, so matching stickers still hide different bills. Xano Essential is $85/mo when you pay annually and want the API drawn instead of written. AWS Amplify has no platform minimum and fits an account already on AWS, while PocketBase publishes no hosted price because you run the binary.

Key facts9 tools compared: Supabase, Firebase, Appwrite, Convex, AWS Amplify, Nhost, Xano, Backendless…
  • Updated: September 28, 2026
  • Top pick: Supabase (best for: Web apps that want Postgres, auth, and files without running the server)
  • Top pick price as of September 28, 2026: Supabase: From $25/mo (Pro, per organization); free plan pauses after 1 week
  • 9 tools compared: Supabase, Firebase, Appwrite, Convex, AWS Amplify, Nhost, Xano, Backendless, PocketBase
  • Firebase (best for: Mobile apps that need offline sync and the rest of Google Cloud): Spark is free; Blaze is usage with no monthly platform fee
  • Appwrite (best for: Teams that want a Docker-hosted BaaS and a per-project cloud bill): From $25/mo per project (Pro); free plan pauses after 1 week
  • Convex (best for: TypeScript apps that should update the client when data changes): From $25/mo per developer (Professional, up to 20); free plan

A backend-as-a-service is a hosted database, auth, file storage, and functions behind one API, so the app does not start with a server you patch. The short list in 2026 is not nine copies of Firebase.

The database and the meter decide it, and a Postgres bill, a per-developer bill, and a peak-requests bill fail in different months.

Toolradar data: Toolradar, the software directory we run, evaluated 109 tools in its September 2026 low-code backend ranking.

That is the nearest public category that actually includes Supabase, Xano, Backendless, Convex, and PocketBase. This page is the developer cut of that market, not the enterprise low-code cut.

Prices below were verified on each vendor's pricing page in September 2026.

The Supabase vs Firebase write-up is the head-to-head if those two are the whole shortlist.

Top Picks

Based on features, real-world fit, and value for money.

Best Backend-as-a-Service Platforms in 2026: 9 tools compared, updated Sep 2026
ToolPricingBest for
SupabaseFrom $25/mo (Pro, per organization); free plan pauses after 1 weekWeb apps that want Postgres, auth, and files without running the server
FirebaseSpark is free; Blaze is usage with no monthly platform feeMobile apps that need offline sync and the rest of Google Cloud
AppwriteFrom $25/mo per project (Pro); free plan pauses after 1 weekTeams that want a Docker-hosted BaaS and a per-project cloud bill
ConvexFrom $25/mo per developer (Professional, up to 20); free planTypeScript apps that should update the client when data changes
AWS AmplifyUsage-based, no monthly minimum; free tier (1,000 build minutes a month)Apps that already live in AWS and should not add another vendor
NhostPro per organization, same entry rate as Supabase; Starter pauses after 1 weekGraphQL APIs on Postgres when Hasura is the interface you want
XanoFrom $85/mo billed annually (Essential); free plan is rate limitedTeams who will draw the API and the business logic instead of writing them
BackendlessFrom $15/mo per app (Scale); free plan for exploringVisual backends where the bill should follow API peaks, not seats
PocketBaseNo public pricing; open-source binary you run yourselfA single-binary backend on a VPS you already operate

Pricing read from each vendor's own published pricing page, checked Sep 2026. 1 of 9 does not publish one; those entries say so rather than estimating.

Lowest published monthly priceSupabase$25FirebaseFreeAppwrite$25Convex$25AWS AmplifyFreeXano$85Backendless$15
Lowest monthly figure each vendor publishes, checked Sep 2026. A tilde marks a figure the vendor states approximately. Per-seat and usage charges can sit on top of it. 2 of 9 do not publish a comparable monthly price and are left out rather than estimated.

Best for: Web apps that want Postgres, auth, and files without running the server

PricingFrom $25/mo (Pro, per organization); free plan pauses after 1 week

+Row-level security is SQL on the table, so every client hits the same rules
+Pro includes 100,000 monthly active users and 8 GB of disk before overage
+Spend caps are on by default on Pro, so usage does not run open-ended unless you allow it
−Free projects pause after a week idle, and only two may be active
−Team, where SOC 2 and ISO 27001 sit, is a separate plan from Pro
Visit Supabase →

Best for: Mobile apps that need offline sync and the rest of Google Cloud

PricingSpark is free; Blaze is usage with no monthly platform fee

+Spark includes Auth, 1 GiB of Firestore, 50,000 document reads a day, and Crashlytics
+Blaze Cloud Functions include 2 million invocations, then $0.40 per million
+SQL Connect adds Cloud SQL for PostgreSQL from $9.37/mo after a 3-month trial
−Spark cannot run Cloud Functions, so that meter starts when the project moves to Blaze
−Phone auth bills per SMS rather than a flat fee, so message volume sets that line
Visit Firebase →

Best for: Teams that want a Docker-hosted BaaS and a per-project cloud bill

PricingFrom $25/mo per project (Pro); free plan pauses after 1 week

+Pro includes 2 TB of bandwidth, 150 GB of storage, 3.5 million executions, and 200,000 MAU
+Self-hosted 1.9.6 installs with Docker and needs 2 CPU cores and 4 GB of RAM
+Free allows two projects, 75,000 MAU, and 750,000 executions
−Self-hosted 1.9 defaults to MongoDB, and MariaDB was the default before 1.9.0, so an upgrade does not keep the old engine
−From 1 September 2026, function and site build artifacts count toward billed storage
Visit Appwrite →
4

Best for: TypeScript apps that should update the client when data changes

PricingFrom $25/mo per developer (Professional, up to 20); free plan

+Professional includes 25 million function calls, then $2 per extra million
+The free allowance is 1 million calls, then $2.20 per extra million, and 0.5 GB of database
+US East is billed at the published 1.0x rate, so the list price holds in that region
−The seat is the developer, so a larger team pays more even when traffic stays flat
−Business and Enterprise start at a $2,500 monthly minimum, and the store is not Postgres
Visit Convex →

Best for: Apps that already live in AWS and should not add another vendor

PricingUsage-based, no monthly minimum; free tier (1,000 build minutes a month)

+Team access is free, with no per-developer charge, so headcount does not move this line
+Standard builds are $0.01 per minute after 1,000 minutes, and large instances are $0.025 per minute
+AWS's published 5-developer example totals $8.08 for build minutes plus hosting
−Auth, APIs, and data are separate AWS services, so the Amplify page is not the whole invoice
−Web Application Firewall is a separate monthly line per app, before the firewall's own usage
Visit AWS Amplify →
6

Best for: GraphQL APIs on Postgres when Hasura is the interface you want

PricingPro per organization, same entry rate as Supabase; Starter pauses after 1 week

+Pro includes 10 GB of database and 50 GB of storage, plus Hasura subscriptions and event triggers
+Database past that allowance is $0.20/GB, storage past 50 GB is $0.05/GB
+Dedicated compute is $50 per vCPU per month, at $0.0012 per vCPU-minute, with 2 GB of RAM per vCPU
−Starter keeps a single project active, so extra free projects have to be paused
−Egress past 50 GB is $0.10/GB, and function time past 10 GB-hours is $0.18 per GB-hour
Visit Nhost →
7

Best for: Teams who will draw the API and the business logic instead of writing them

PricingFrom $85/mo billed annually (Essential); free plan is rate limited

+Essential drops the free cap of 10 requests per 20 seconds and adds direct database access
+The paid Postgres database is not capped at the free plan's 100,000 records
+Essential lists SOC 2, ISO, and GDPR, with 5 seats and 3 workspaces
−The Essential and Pro rates are the annual-billing prices, and the month-to-month figure is a different number
−Free file storage is 1 GB and watermarked, and branching starts on Essential rather than Free
Visit Xano →

Best for: Visual backends where the bill should follow API peaks, not seats

PricingFrom $15/mo per app (Scale); free plan for exploring

+Developer seats are unlimited, and Scale Variable tier 1 is $0.50 per day at 0 to 5 requests per minute, so a quiet large team stays near the floor
+Scale raises realtime connections from 5 on Free to 1,000, and tables from 20 to 100
+File storage on Scale is 10 GB, and another 10 GB is a $20/mo pack
−Cloud Code still stops at 5 seconds on Scale, and the 20-second pack is $30/mo, so a longer job is an add-on
−A quiet app can sit near the published monthly floor, and a spiky day jumps tiers inside the same month
Visit Backendless →

Best for: A single-binary backend on a VPS you already operate

PricingNo public pricing; open-source binary you run yourself

+Version 0.40.4 bundles the database, auth, files, and an admin UI in one binary
+Hooks in Go or JavaScript extend it without a second vendor
+Files can stay on local disk or move to S3
−You own uptime, backups, and disk, because the project publishes no managed plan and no SLA
−The database is embedded SQLite, so a second app server does not share it the way Postgres does
Visit PocketBase →

What it is

You are buying a data store plus sign-in, files, code that must not ship in the client, and usually a generated API, and the purchase is not a language.

Supabase, Nhost, and Xano put Postgres under that API, so a team that already writes SQL can leave with a dump instead of a rewrite.

Firebase's default store is Firestore, which suits a phone client that needs offline sync and is the wrong store when the data is relational.

Convex stores documents and exposes TypeScript functions, so you are buying reactivity rather than portable SQL. Appwrite Cloud's default is TablesDB, while the self-hosted 1.9.6 install defaults to MongoDB, so the cloud project and the Docker box are not the same database.

Hosted and self-hosted are different products even when the logo matches.

Supabase's Docker setup and the CLI are free to run yourself, which is the exit when the pause or the organization bill is the objection. Appwrite ships 1.9.6 as a Docker installer and asks for 2 CPU cores and 4 GB of RAM, so self-hosting has a hardware floor.

Convex offers self-hosting if the team will operate the box to leave the per-developer meter.

PocketBase is the open-source binary, version 0.40.4, with no cloud SKU, so the cost is the machine and the person who patches it.

How we compared: we read nine vendors' own pricing and product pages, in USD, and ranked them for someone shipping an app rather than buying an enterprise low-code suite.

The 109-tool Toolradar category is the sample around that shortlist. This is not a load-test report.

Why it matters

The invoice breaks in two places developers notice late. Free projects pause on Supabase, Appwrite, and Nhost after a week idle, so a demo is asleep when a teammate opens it, fine for a side project and fatal for shared staging.

A five-person Convex team pays the Professional rate five times, while a five-person Supabase org pays the org rate once and then compute per project.

Lock-in is the schema, not the logo: a Supabase project can leave through SQL you already know, so the hosted plan stays a rental.

A Firestore project leaves through an export and a rewrite, which is what you pay when you change stores.

Amplify leaves through Cognito, Lambda, and whatever store you attached, a fair cost when the company already lives in that account and an expensive one when it does not.

If the frontend is still undecided, the serverless platforms guide covers where the UI is deployed, and the Vercel review is the common pair with a hosted Postgres backend.

When you want to drop the wrapper and keep the rows, the Postgres hosting guide is the next page, and GraphQL tools is the page when Hasura is the actual question. Stack changes like these show up in the Devshot brief.

Key features to look for

The database you can leave
Postgres you can dump, a document store, or SQLite in one process: the exit cost is the feature that decides the buy.
What the free project does when idle
Several free tiers pause after a week, which a side project survives and a shared staging database does not.
The billing unit
Per organization, per project, per developer, or per peak minute of traffic, because headcount and traffic move different bills.
Auth and files in the same project
Row-level policies, GraphQL permissions, or security rules, depending on whether authorization lives next to the rows.
A place for server code
Edge functions, Cloud Functions, or a visual workflow, and Spark Firebase cannot run functions until you turn billing on.
Who operates the disk
Managed backups and a pause button, or a binary on a VPS you patch, which is the PocketBase choice.

Pricing

Four hosted products cluster at one entry sticker, and then the meters diverge.

Supabase bills the organization and then compute per project: Micro is $10/mo, and Pro credits cover one of those, so an extra project opens a new line.

Appwrite bills Pro per project and prices a dedicated Micro database on that same compute line, with monthly credits beside it, so each app is its own subscription.

Past Pro's included 2 TB, extra bandwidth is billed per 100 GB, and storage past 150 GB is $2.8 per 100 GB, which is how file traffic leaves the flat subscription.

Firebase and Amplify publish no platform subscription, which keeps a quiet app cheap and gives a busy one no floor.

Blaze adds $0.40 per million function calls after the included 2 million, hosting transfer at $0.15/GB after 360 MB a day, and Realtime Database storage at $5/GB after 1 GB.

Amplify data transfer is $0.15/GB after 15 GB, CDN storage is $0.023/GB after 5 GB, and the published five-developer example is $8.08.

New AWS accounts can apply up to $200 in Free Tier credits, which delays that meter until the credits are gone.

Convex Professional is per developer, not per org, and the Business floor is $2,500/mo, so headcount moves the bill before traffic does.

Nhost Team and Supabase Team are each $599/mo when you need the compliance line. Xano Pro is $224/mo on annual billing, with a 99.99% SLA and 10 seats, the plan you reach when Essential runs out of seats.

Backendless Scale Variable adds daily tiers up to $230 for 7,001 to 10,000 requests per minute, so a spike bills that day rather than at renewal.

PocketBase has nothing to put on an invoice until you rent the machine, which is a VPS question, not a BaaS price.

Overage is where the entry plan stops being the bill. Supabase meters disk, egress, monthly active users, branch hours, and point-in-time recovery as separate lines.

Nhost's point-in-time recovery starts at $100 for 7 days, the same add-on shape as Supabase.

Appwrite bills extra executions per million past the Pro allowance, so a busy function can outrun the subscription. The rates are in the table, verified on the vendor pricing pages in September 2026.

PlanPriceBest for
Supabase FreeFree50,000 MAU, 500 MB database, pauses after 1 week, 2 active projects
Supabase Micro compute$10/moShared CPU, 1 GB RAM; Pro credits cover one instance
Supabase extra MAU$0.00325 eachAfter 100,000 monthly active users on Pro
Supabase disk$0.125/GBAfter 8 GB per project on Pro
Supabase egress$0.09/GBAfter 250 GB on Pro
Supabase branching$0.01344 per branch-hourPro and above
Supabase PITR$100 per 7 daysPoint-in-time recovery, per project
Supabase Team$599/moSOC 2, ISO 27001, 14-day backups
Firebase SparkFree1 GiB Firestore, 50,000 reads/day, no Cloud Functions
Firebase Cloud Functions$0.40 per millionAfter 2 million invocations on Blaze
Firebase SQL ConnectFrom $9.37/moCloud SQL for PostgreSQL after a 3-month trial
Firebase Hosting transfer$0.15/GBAfter 360 MB/day on Blaze
Firebase Realtime Database storage$5/GBAfter 1 GB stored on Blaze
Firebase Remote Config$0.06 per 10,000Above 100,000 fetches a day, in effect since 1 September 2026
Appwrite FreeFree5 GB bandwidth, 2 GB storage, 750,000 executions, 75,000 MAU
Appwrite extra bandwidth$15 per 100 GBOn Pro, past the included 2 TB
Appwrite extra storage$2.8 per 100 GBPast 150 GB on Pro
Appwrite extra executions$2 per millionPast 3.5 million on Pro
Appwrite dedicated Micro$10/mo1 GB RAM, plus monthly database compute credits
Convex free calls$2.20 per extra millionAfter 1 million function calls
Convex Professional calls$2 per extra millionAfter 25 million function calls
Convex database storage$0.22/GBFree plan, after 0.5 GB
Convex Business$2,500/mo minimum50+ developers, SAML, service SLAs
Amplify standard build$0.01 per minuteAfter 1,000 build minutes a month
Amplify large build$0.025 per minute16 GB memory, 8 vCPUs, no free minutes
Amplify data transfer$0.15/GBAfter 15 GB a month
Amplify CDN storage$0.023/GBAfter 5 GB stored
Amplify SSR requests$0.30 per millionAfter 500,000 requests a month
Amplify WAF$15/mo per appPlus the firewall's own usage
Amplify published example$8.08/moAWS's 5-developer, 300-DAU build plus hosting example
Nhost database overage$0.20/GBAfter 10 GB on Pro
Nhost storage overage$0.05/GBAfter 50 GB on Pro
Nhost egress$0.10/GBAfter 50 GB on Pro
Nhost function time$0.18 per GB-hourAfter 10 GB-hours on Pro
Nhost extra functions$5 per 50After 50 functions on Pro
Nhost dedicated vCPU$50 per vCPU/mo$0.0012 per vCPU-minute, 2 GB RAM per vCPU
Nhost custom domain$10 per project/moAdd-on, including on paid plans
Nhost point-in-time recovery$100 for 7 daysStarts at that retention window
Nhost Team$599/moSOC 2 Type II, support SLA
Xano Essential$85/mo billed annually5 seats, 3 workspaces, no platform rate limit
Xano Pro$224/mo billed annually10 seats, 5 workspaces, 99.99% SLA
Backendless ScaleFrom $15/mo per appVariable tier 1 is $0.50/day at 0 to 5 requests per minute
Backendless top variable tier$230 per day7,001 to 10,000 requests per minute
Backendless extra file storage$20/moAnother 10 GB
Backendless longer Cloud Code$30/moRaises the 5-second cap to 20 seconds
Backendless security pack$399/moPanic mode, audit log, HIPAA tools
PocketBaseNo hosted priceOpen-source binary, v0.40.4, SQLite included
Mistakes to avoid
×Treating a paused free project as staging means the database is down when a teammate opens the link, because Supabase, Appwrite, and Nhost pause idle free projects after a week.
×Comparing Convex's developer price with Supabase's organization price as if they were the same headcount undercounts one side: five developers on Professional is five seats, while five developers on Supabase Pro is one org and then a compute line per project.
×Turning on Firebase Blaze for a function and forgetting phone auth and Remote Config. SMS is metered, and Remote Config above 100,000 fetches a day has been billed since 1 September 2026.
×Assuming Appwrite Cloud and a self-hosted 1.9 box share a database. The install guide defaults new self-hosted instances to MongoDB. Dedicated cloud databases are a separate choice, including Postgres.
Expert tips
→Write the billing unit on the shortlist before the feature grid: org, project, developer, or peak requests per minute, because the feature lists overlap and the invoices do not.
→If the data has to remain SQL you can host elsewhere, start with Supabase or Nhost and keep policies in the database. Dropping the wrapper later is a hosting move, not a rewrite of the rows.
→Run PocketBase only where someone already patches a VM. Pair it with a host you operate, and keep the binary's data directory in the backup you already trust.

The bottom line

Start on Supabase when the app is a web product and you want Postgres, auth, and files on one bill. Move to Firebase when the client is mobile and offline sync is the requirement, and accept that functions require Blaze.

Pick Appwrite when a Docker install on 4 GB of RAM is the exit you want written down, and Convex when the team will live in TypeScript and will pay per developer.

Amplify belongs to teams whose account and compliance review are already AWS.

Nhost belongs to teams that want Hasura in front of Postgres, and Xano belongs to teams that will maintain logic in a visual builder and will pay the annual Essential rate.

Backendless belongs where seats should be free and API peaks should set the bill, and PocketBase belongs on a machine you already run.

We re-read these pricing pages for the developer shortlist, separate from the 109-tool category ranking. Cite this: Devshot, "Best Backend-as-a-Service Platforms in 2026", September 2026.

Frequently asked questions

What is the best backend-as-a-service in 2026?
Supabase, for a web app that should sit on Postgres. Pro is the organization plan, the free project pauses after a week, and you can self-host the Docker setup. Choose Firebase when the app is mobile and offline sync matters, Appwrite when you want the 1.9.6 Docker install as the exit, and Convex when the backend should be TypeScript functions billed per developer.
How much does a backend-as-a-service cost?
Hosted entry plans from Supabase, Appwrite, and Nhost are organization or project subscriptions, and Convex Professional is per developer, so the same kind of entry plan is not the same invoice. Xano Essential is $85/mo billed annually, and Xano Pro is $224/mo billed annually. Supabase Team and Nhost Team are $599/mo when you need the compliance line. Firebase Blaze and AWS Amplify have no platform subscription: Amplify's own five-developer example is $8.08, and Backendless Scale is priced per app rather than per seat. PocketBase publishes no hosted price because you run the binary. Figures were verified on vendor pricing pages in September 2026.
Is there a free backend-as-a-service?
Yes, Supabase, Firebase Spark, Appwrite, Convex, Nhost Starter, Xano, and Backendless each publish a free plan, and the limit is what that plan will actually run. Supabase, Appwrite, and Nhost pause an idle free project after a week, so the free tier is a demo and not shared staging. Firebase Spark includes Firestore and Auth but not Cloud Functions, so a server-side job forces a move to Blaze. Xano's free plan allows 10 requests per 20 seconds and watermarks images. PocketBase is free because you run it, not because a vendor hosts a free tier.
Supabase vs Firebase: which should a developer pick?
Supabase when the data is relational and you want to leave with SQL. Firebase when the clients are iOS, Android, or Flutter and offline sync is part of the product. Firebase SQL Connect can add Cloud SQL from $9.37/mo after the trial, which narrows the SQL gap without making Firestore a Postgres database. The longer comparison is the Supabase vs Firebase note, and each product has a Supabase review and a Firebase review.
Is Appwrite a better self-hosted backend than Supabase?
Appwrite's install is one Docker flow, and the current self-hosted release is 1.9.6, with a 2-core and 4 GB RAM floor. New installs default to MongoDB, so skip it when the rows must stay SQL. Supabase self-host is also Docker, and the database is Postgres, which is why most web teams still start on the hosted Pro plan instead. Pick Appwrite self-host for the smaller install, and Supabase when the rows need to stay SQL.
When is AWS Amplify the right backend?
When the account, the VPC, and the compliance review are already AWS. Amplify does not charge per seat, standard builds are $0.01 per minute after 1,000 minutes, and a Web Application Firewall is a separate monthly line per app. You still pay Cognito, Lambda, and the database on their own pages. If the team is not already in that account, Supabase or Appwrite is a smaller surface to operate.
Can I move off a BaaS later?
Postgres-backed projects move with a dump: Supabase, Nhost, and Xano are in that group, with the caveat that Hasura permissions and Xano workflows do not travel inside the dump, so the rows move and the logic often does not. PocketBase moves as a SQLite file plus your hooks, enough when one process owns the data. Firebase, Convex, and Amplify move as an export and a rewrite, which is the cost of leaving those stores. Appwrite self-hosted 1.9 is MongoDB or MariaDB, so the exit is that database's tools, not pg_dump, unless you chose a dedicated Postgres database on the cloud plan.

Sources

Prices and plan details come from each vendor's own pricing page, re-checked by the Toolradar pricing tracker.

Related guides

Some offers on this page may be paid placements or contain affiliate links.

Get the Devshot brief

Free daily newsletter, read in 5 minutes.

Subscribe free