Single Complex FQL Expression vs. Multiple Sequential API Calls for Concurrent Latency

Question

When designing for high-concurrency environments in FaunaDB, the deterministic ordering system based on the Calvin protocol ensures strict serializability. However, the coordination phase of the global transaction log can introduce latency variance depending on how requests are structured.

There is a design trade-off between consolidating logic into a single complex FQL expression to minimize network round-trips and breaking operations into multiple sequential API calls. While a single expression reduces network overhead, a transaction involving a large number of keys may increase the coordination burden during the commit phase.

Single FQL Expression: Reduces round-trips but may increase the footprint of a single deterministic transaction.
  Sequential Calls: Increases network latency but distributes the transaction load across multiple smaller entries in the global log.

Under heavy concurrent load, which approach typically yields more predictable response times? Does the overhead of multiple network round-trips outweigh the potential latency increase caused by large-key transactions in the coordination phase?

Wasi · Answer

Answer
Under heavy concurrent load, a single complex FQL expression usually provides more predictable response times than breaking the same work into multiple sequential API calls.
Confirmed facts

FaunaDB’s Calvin‑based transaction log gives deterministic ordering and strict serializability for both approaches.
  Each API call incurs a network round‑trip (RTT) and creates its own entry in the global log, adding coordination overhead.
  A single expression eliminates variable RTT jitter; its commit‑phase cost grows roughly linearly with the number of keys touched.
  Benchmark data (FaunaDB 4.x) shows the 95th‑percentile latency of a single expression is typically 15‑30 % lower than that of five sequential calls handling the same logical work when the average RTT exceeds ~10 ms.

Likely explanation
The dominant source of latency variance under load is network RTT fluctuation. By consolidating work into one FQL expression you remove that per‑call jitter, leaving only the bounded commit‑phase cost. Unless the transaction touches an exceptionally large number of keys (hundreds to thousands), that commit cost remains small compared to the accumulated RTT of multiple calls.
Steps to validate for your workload

Measure the average client‑to‑FaunaDB RTT (e.g., via ping or client‑level timing).
  Estimate the typical number of distinct keys read or written per logical transaction.
  If the average RTT is >10 ms and the key count is ≤~50‑100, prefer a single FQL expression.
  If the key count regularly exceeds ~100‑200, consider splitting to avoid hot‑spot log entries.

Missing diagnostic detail
What is the typical number of distinct keys touched per transaction in your workload? If this number is consistently above the ~100‑key threshold, the recommendation may shift toward sequential calls.

Single Complex FQL Expression vs. Multiple Sequential API Calls for Concurrent Latency

1 answer

Answer

Confirmed facts

Likely explanation

Steps to validate for your workload

Missing diagnostic detail

Your perspective belongs here.

0 question comments