Running Fauna?

Fauna FQL v10 migration or indexes acting up? We bring it back.

Fauna looks friendly on the surface and turns into a specialist database quickly. FQL v10 is a different language from v4, index resource usage can blow a budget without warning, and the shutdown of the older service forced a lot of teams to port in a hurry. We work through the schema, the queries and the UDFs until the bill, the latency and the semantics all line up again.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

fauna-shell.log

still failing

What it is

Fauna at a glance

Fauna is a globally distributed document relational database that mixes a document model with ACID transactions and a strongly typed query language. The product first shipped in 2017, and FQL v10 landed in 2023 as a full rewrite of the query language around a more TypeScript shaped syntax, replacing the earlier Lambda style FQL v4.

In 2025 the original Fauna service announced a shutdown date, and customers were pushed to migrate either to the new FaunaDB offering or off the platform entirely. That migration is where most of our calls about Fauna now begin. The engine itself remains an interesting fit for multi region, consistent document workloads, provided you understand how indexes, roles and FQL v10 differ from the older generation.

Type
Distributed document relational database
First released
2017 public general availability
License
Proprietary managed service, usage based pricing
Maintained by
Fauna, Inc.
Typically used for
Multi region SaaS backends, user and tenant data, serverless applications needing strong consistency

The honest version

Fauna pros and cons

No technology is all upside. This is where Fauna earns its place and where it tends to cause trouble.

Where Fauna is strong

  • Global ACID transactionsWrites commit with strict serializability across regions, which few other managed document databases offer, and it removes a lot of application level locking code.
  • A single query language with real expressivenessFQL v10 covers queries, writes, joins and UDFs in one surface, so you do not juggle SQL plus a separate stored procedure dialect.
  • Granular role based access controlRoles can be scoped to collections, documents or specific predicates, which lets you push authorization logic into the database rather than reinventing it in every service.
  • Schema evolution without downtimeAdding fields, computed fields and indexes is online, so schema change does not require maintenance windows.
  • Document model with relationsReferences between documents are first class, so you keep flexible shapes without giving up joins the way you do on a pure key value store.
  • Serverless billing modelNo cluster to size, no idle fleet to pay for, and scaling to zero is possible for low traffic tenants.

Where Fauna bites

  • FQL v10 is a hard break from v4The language, the drivers and many query patterns changed. Teams migrating from v4 effectively rewrite their data layer, and existing blog posts and Stack Overflow answers are often v4 only.
  • Index resource usage is easy to blowA query that lacks a covering index falls back to a scan, which runs up index_byte_read_ops and shows up as a surprising bill rather than a visible error. Monitoring helps but it is not default.
  • Smaller community and talent poolFauna is a niche pick compared with DynamoDB or MongoDB, and finding engineers with FQL v10 experience on short notice is hard.
  • Lock in is significantFQL is not SQL, and moving off Fauna means porting both schema and queries. Exports cover the data but not the UDFs or role definitions.
  • Error messages can be opaqueA contended_transaction or invalid_query response often needs the team to decode the context, and the shell output is terse compared with Postgres or MongoDB tooling.
  • Service continuity riskThe 2025 shutdown of the original service put long term planning for Fauna under real scrutiny. Betting a product on a single managed vendor needs a migration plan on the shelf.

Sound familiar?

Common Fauna problems we fix

The Fauna problems that bring people to us, and what you have once each one is fixed.

FQL v4 driver will stop working

FQL v4 to v10 migration is overdue

A codebase that still speaks v4 after the deprecation window, with queries, UDFs and role definitions that need to be ported one collection at a time.

Code on v10, v4 retired

limit_exceeded: index_byte_read_ops

A query is burning index resources

A read path that hits a collection scan because the index does not cover the filter, running up operations fast and showing up on the next invoice.

Indexes cover the hot reads

contended_transaction: aborted

Transactions are retrying under load

Two writers touching the same document or index key at the same time, producing optimistic concurrency aborts that the client has to retry.

Hot writes decontended

invalid_schema: cannot change field type

A schema change is being rejected

A field whose declared type would conflict with existing documents, so the collection refuses the update until the data is backfilled or the field is renamed.

Schema evolves without breaking reads

insufficient_privileges

A role or key is missing a permission

A role definition that does not grant read or write on a collection a UDF depends on, so queries work in development but fail in staging with a less privileged key.

Roles grant exactly what is needed

timeout: query exceeded 30s

A query will not finish inside the timeout

A large set iteration, a paginate without the right bounds, or an aggregate over too wide a range, all showing up as a hard timeout rather than a slow response.

Queries bounded and paginated

payload_too_large: 8MB

A document write is being rejected as too large

A document that grew past the 8 MB limit, often because an array or a nested structure was never bounded.

Documents sized and split

constraint_failure: unique

A unique constraint is firing in production

A collection with a unique index on a field that the application assumed was unique only within a tenant, causing writes to fail when two tenants share a value.

Constraints match the model

What we do

Fauna help, from v10 migrations to index tuning

We take on a single failing query, or the whole FQL v4 to v10 move, whichever you need.

Rescue
A Fauna database refusing writes, a UDF that errors under load, or a role that unlocked too much. We stabilize the surface first.
FQL v10 migration
Porting FQL v4 queries, UDFs and role definitions to v10 incrementally, with tests that prove behavior stayed the same.
Index and query tuning
Index coverage on the hot reads, paginate patterns that do not run away, and a bill you can actually predict.
Schema and roles
Collection shapes, computed fields and role scopes worked out so authorization lives where it belongs.
Exit planning
If Fauna has stopped being the right pick, we export data, port queries to the target store and decommission cleanly.
Managed Tech
Index usage monitoring, FQL upgrades, and a database engineer on call when the dashboard raises an alert you do not have time to parse.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Fauna alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Fauna questions

Something else? Call+1 737 727 7327

How hard is the FQL v4 to v10 migration?

Harder than a driver swap, easier than moving to a different vendor. The language syntax is new, Lambda style v4 queries do not translate line by line, and UDFs and roles usually need rewriting rather than editing. A typical migration takes weeks of engineering for a non trivial product, and the useful trick is to port one collection at a time rather than attempting the whole data layer in one pass.

Why is my Fauna bill so high?

Usually a query that is scanning rather than using a covering index, or paginate calls that walk a much larger set than the UI actually displays. Fauna charges for the operations, and a missing index on a hot read quietly runs up index_byte_read_ops into real money. We find the offenders in the usage dashboard and in the query logs.

Should we stay on Fauna after the service changes?

That depends on your workload, your appetite for a niche vendor, and how much of your code is already FQL. For teams that have not started v10 and whose data model is plain documents, DynamoDB, MongoDB or Postgres JSONB are often the simpler long term call. For teams that rely on Fauna's global ACID guarantees, staying is defensible, and we will say so.

How do we fix contended_transaction errors?

Those are optimistic concurrency aborts. The two usual causes are two writers updating the same document or index key, and a UDF that reads and writes the same document in a hot path. Rewriting the hot path to use set operations or to serialize through a tenant key usually calms it down. Blind client side retry alone just increases the bill.

Can we move off Fauna without downtime?

Usually yes. The technique is dual writes to Fauna and the new target for a window, with reads moving across one surface at a time. Fauna's export covers documents cleanly; roles and UDFs need to be reimplemented in the target system. The project is measured in weeks, not days.

How much does Fauna help cost?

Our estimates are complimentary. Describe the collections and what the dashboard is showing, and a price goes out before any engineer touches your data.

Free estimate

Fauna tripping your team up?

Share a failing query or a short note on your schema, and a database engineer comes back with a plan and a price.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.