The Search for Speed in Figma | Figma Blog

Figma’s search investigation revealed that OpenSearch itself was responsible for less than 30% of total search latency. The larger costs came from query construction and especially permission checks before and after searches. By measuring the correct end-to-end metrics, Figma identified misleading monitoring data and established a foundation for improving search performance at scale.

Diagnosing the Latency Gap

• Figma migrated from an older Elasticsearch version to AWS-managed OpenSearch, a fork created after Elasticsearch’s 2021 license change.
• OpenSearch reported an average search time of roughly 8 ms, while Figma’s API showed:
  • About 150 ms average latency
  • 200–400 ms latency at the 99th percentile
  • Minimum latency above 40 ms
• Search performance also varied significantly depending on traffic levels, with peak periods much slower than weekends.
• Additional instrumentation showed that substantial time was spent both before and after the OpenSearch request.

Understanding OpenSearch’s Metrics

• OpenSearch distributes a query through a coordinator node to worker nodes, typically sending one request per index shard.
• It then gathers, sorts, and fetches results during the query and fetch phases.
• The reported 8 ms metric measured only the average time for individual shard queries—not the total time required to coordinate hundreds of shard requests.
• Figma’s queries could involve as many as 500 shard-level requests, many of which ran in parallel but not all.
• OpenSearch did not provide built-in metrics or logs for overall query duration.
• Figma instead extracted the took value from each search response, producing a backend latency measure that aligned more closely with application-level timing.

Permission Processing as the Main Bottleneck

• Less than 30% of total query API time was spent waiting for OpenSearch.
• Pre-processing:
  • Retrieved information about files the user could access.
  • Built an OpenSearch filter intended to exclude inaccessible files.
• Post-processing:
  • Performed additional permission checks on every returned file.
  • Was especially slow and consumed more time than the search itself.
• The investigation demonstrated that optimizing the search engine alone would not solve Figma’s overall latency problem.

Figma’s experience highlights the importance of measuring end-to-end request latency rather than relying on subsystem metrics. Accurate coordinator-level and application-level instrumentation is essential, particularly when distributed searches involve many shards and expensive authorization work.