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
Running Fauna?
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.
What it is
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.
The honest version
No technology is all upside. This is where Fauna earns its place and where it tends to cause trouble.
Sound familiar?
The Fauna problems that bring people to us, and what you have once each one is fixed.
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
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
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
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
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
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
A document that grew past the 8 MB limit, often because an array or a nested structure was never bounded.
Documents sized and split
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
We take on a single failing query, or the whole FQL v4 to v10 move, whichever you need.
How it works
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
We fix the cause, not the symptom. If something is down, getting it back up comes first.
Backups, monitoring, updates and access, so the same problem can't quietly come back.
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
We work on the whole stack, so the problem can be wherever it actually is.
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.
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.
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.
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.
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.
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
Share a failing query or a short note on your schema, and a database engineer comes back with a plan and a price.
Your message is with a real person, and we'll get back to you soon.
Rather talk now? Call us: