Fauna Alternatives After the Shutdown: Picking a Durable Home

Fauna's database service ended on May 30, 2025, and all accounts and their data were deleted after that date. If you are choosing a Fauna alternative now, the best fit depends on what you liked about Fauna: Convex is closest to its document-relational, transactional, serverless feel; Postgres backends such as StitchDB and Supabase give you an open standard with auth and APIs included; Neon gives serverless Postgres alone; Firebase and MongoDB Atlas suit teams that want documents. Whatever you pick, the lesson from Fauna is to choose a database you can export and run somewhere else.

#What happened

Fauna announced in March 2025 that it would wind down the service and turned it off on May 30, 2025, giving customers about two months to move. Its end-of-life FAQ said accounts and data would be permanently deleted afterwards, and the company said it intended to release its core technology as open source. Many teams moved in a hurry; some ended up on a stopgap and are now picking a long-term home.

#What Fauna users usually want

Fauna had an unusual mix of traits. Ranking them helps you pick:

1. Strong consistency and transactions across documents.
2. Serverless operation: no instances to size, pay for use.
3. Documents with relations: references between documents and joins in FQL.
4. An HTTP API usable from the browser and edge runtimes, with fine-grained access control.
5. A built-in permission model using roles and predicates.

No single product today copies all five. The table shows how close each alternative comes.

#Fauna alternatives compared

#The alternatives

#Convex: the closest in spirit

Convex stores documents in tables, runs your queries and mutations as TypeScript functions inside the database, and keeps every client subscription on the same consistent snapshot. Its docs describe a relational data model with no SQL to write. For a team that liked FQL's "logic next to the data" approach, it is the most natural move. Free & Starter includes 1M function calls and 0.5 GB of storage; Professional is $25 per developer per month (as of November 2026). The backend is published under FSL Apache 2.0 and can be self-hosted, which addresses the "what if the vendor goes away" question. See Convex alternatives.

#StitchDB: Postgres with the app layer included

StitchDB gives each project its own Postgres database plus Auth, a REST API generated from your schema, GraphQL, Realtime, Storage and Deno Edge Functions. For Fauna users who called the database straight from browsers or edge functions, two parts matter:

• The REST API works from any HTTP client, with row level security enforcing access per user.
• The serverless driver runs SQL over HTTPS and WebSockets from Cloudflare Workers, Vercel Edge and Deno Deploy, with batched transactions and interactive sessions, for runtimes without TCP.

A Fauna role predicate such as "a user can read documents where owner is the caller" becomes:

create policy "owner can read" on public.documents
  for select to authenticated
  using (owner_id = auth.uid());

The answer to "can I leave?" is built in: every plan can export the whole project as one archive with a pg_dump custom-format file, auth users with bcrypt password hashes, stored files, Edge Function source and settings. The dump restores into any Postgres 15 or newer with pg_restore.

Prices as of November 2026: Free $0, Pro $15.99/month, Scale $49/month, with a spend cap on by default for paid plans. See pricing.

Trade-offs: you trade Fauna's document model for SQL, so data and queries need redesigning. Regions are EU-only (Germany and Finland), there is no self-hosted edition, and StitchDB is a young platform; the export exists precisely so that this is not a trap.

#Supabase

The open source Postgres backend: Auth, REST, GraphQL, Realtime, Storage and Edge Functions, 17 AWS regions, and self-hosting with Docker. Free projects pause after a week of inactivity; Pro is from $25/month (as of November 2026). If "could I run this myself tomorrow" is your top requirement, Supabase's self-host option is the strongest answer among full backends.

#Neon

Serverless Postgres with scale-to-zero and branching. Free includes 100 projects with 1 GB each; Launch and Scale are usage-based with no monthly minimum (as of November 2026). Neon is a database only, so you add auth and an API yourself.

#Firebase

If you want to stay schemaless and serverless, Firestore is the most mature option, with transactions and strong client SDKs. You accept Google Cloud lock-in and pay-per-operation billing on Blaze.

#MongoDB Atlas

Documents with multi-document transactions and a free M0 cluster (512 MB). Note that MongoDB deprecated the Data API and HTTPS Endpoints, so browser or edge access now goes through an API you build. See MongoDB Atlas alternatives.

#Moving Fauna-shaped data to Postgres

If you still hold a Fauna export in JSON, the move to Postgres follows a pattern:

1. One table per collection. Fields you filter or join on become columns; the rest goes into a jsonb column.
2. References become foreign keys. Keep the old document IDs as text so links resolve.
3. Indexes. Each Fauna index you queried becomes a Postgres index on the matching columns (or a GIN index on jsonb).
4. UDFs become SQL functions callable over REST with rpc():

create function public.cart_total(cart text) returns numeric
language sql stable as $$
  select coalesce(sum(price * qty), 0) from public.cart_items where cart_id = cart
$$;

const { data: total } = await stitchdb.rpc('cart_total', { cart: cartId })

5. Roles become RLS policies, as shown above.

#A quick decision path

• You still have a Fauna export and a stopgap host, and the app works: pick the long-term home on portability first, features second.
• Your app called the database from the browser: choose a platform with a generated API and per-user rules (StitchDB, Supabase, Firebase, Convex).
• Your logic lived in UDFs: Convex (TypeScript functions) or Postgres functions are the natural homes.

#How to avoid the next shutdown scramble

• Prefer an open data format (Postgres, MongoDB, SQLite) over a proprietary one.
• Check that you can export everything, including users and files, not just rows.
• Run a test restore somewhere else once a quarter.
• Keep your app talking to standard APIs where possible, so the client code survives a host change.

For more on keeping backups you can trust, read Postgres backup best practices.

#FAQ

#When did Fauna shut down?

The service was turned off on May 30, 2025, and Fauna said accounts and data would be deleted afterwards.

#What is the closest alternative to Fauna?

Convex is closest in model (transactional, document-relational, logic next to the data). Postgres backends are the most portable choice.

#Did Fauna release its code as open source?

Fauna said it intended to open source its core technology. Check the company's own channels for the current status.

#Can I query Postgres from Cloudflare Workers like I did with Fauna?

Yes. StitchDB's REST API and serverless driver work over HTTPS from Workers and other edge runtimes.

Choose a backend you can always take with you: start a free StitchDB project.