march changelog

tpuf.link/chlog

a 3D lego model of turbopuffer’s mascot, puffy, is held up against an aquarium backdrop. puffy is right at home amongst the aquatic life.

A group of people enjoy an aquarium scene, admiring fish swimming in vibrant blue water under a dome structure.

An event banner highlights “A night at the aquarium,” while guests explore an underwater tunnel with vibrant lighting.

puffy was right at home at our AI night at the aquarium in London

coming to {a city near you}

each object store has its tradeoffs

GCS has great throughput but limits per-object replaces to 1/s. S3 has no rate limit, but lower throughput

we coalesce writes into larger WAL commits to respect GCS, but we've now increased commit cadence on S3 for ~2.5x lower write latency

turbopuffer x ElevenHacks ElevenHacks #4 with turbopuffer and ElevenLabs — signup credits, hackathon prizes, and resources for your build.

ElevenHacks #4 → turbopuffer x ElevenLabs

🥇 $8,192 first prize
🥈 $4,096 second prize
🥉 $1,024 third prize

challenge drops tomorrow at 9a pt / 12p et

sign up below ($128 in tpuf credits to get you started)

tpuf.link/11hacks

Code snippet for configuring a multivector database entry, including title, image URI, and embedding details for text and images.

new: multiple vector columns

store multiple embeddings for the same document - each with its own dimensions, types, and ANN index

multimedia → multiple vectors

docs: tpuf.link/multi-vec-cols

new to tpuf: ranking by attribute for full-text search

incorporating attributes into the MAXSCORE skipping algorithm → more levers for first-stage search relevance

docs: tpuf.link/rba-docs

february changelog

tpuf.link/chlog

A chart showing p90 query latency performance gains for regex and glob filters after the introduction of a trigram regex index on turbopuffer. Latency improved from 115 milliseconds to 33.8 milliseconds for a representative regex filter and from 267 milliseconds to 34.2 milliseconds for a representative globbing filter. The chart suggests that while these kinds of filters already worked, now they puff!

new in tpuf: regex indexes

regex and glob filters can now use a trigram index to avoid full-table scans

tpuf AND filters are now up to 30% faster

Superhuman Mail trusts 5x more emails to turbopuffer Superhuman Mail's previous vector database was so unreliable they limited each search index to just 1 year of email and ran features on Postgres to avoid overloading it. turbopuffer gave them the confidence to index 5x more data, consolidate their search stack, and stop worrying if the infra could handle it.

Superhuman Mail increased indexed email history from 1 → 5 years per user on turbopuffer

"I will always pick a product with great reliability over a product with great features. turbopuffer has both" - Rafael Melo Cardoso, Engineering Manager

tpuf.link/superhuman

Pricing Changelog Changes to turbopuffer's pricing

more details in the pricing changelog: tpuf.link/pricing-feb-26

we’ve reduced query prices by up to 94%, thanks to infrastructure improvements we've made under the hood

puff harder, for much less

A series of three grouped bar charts displays the latency in milliseconds for filtered BM25 queries over 5 million documents before and after optimization, showing up to 20% speedups depending on query when a 1% matching filter is applied.

78% of tpuf text searches include a filter. they are now up to 20% faster

before → always score first, then filter
now → filter first (when cheaper), then score

How to build a distributed queue in a single JSON file on object storage How to build a single global queue for distributed systems on object storage: Start with a single file on object storage, then add write batching, a stateless broker, and high-availability.

queue.json on object storage is all you need to build a reliable distributed job queue

→ FIFO execution
→ at-least-once delivery
→ 10x lower tail latencies

tpuf.link/queue

Vercel indexes its entire GTM memory on turbopuffer Vercel's GTM engineering team built an AI lead agent that can access Gong transcripts, Slack channels, and Salesforce data. It's already saved over $2M.

Vercel's GTM engineers built an AI agent that searches across Gong, Slack, and Salesforce - helping sales work deals with better context

"I realized I could index Vercel's entire GTM corpus on turbopuffer with just my credit card." - Drew Bredvick

tpuf.link/vercel

January 2026 changelog list on dark background detailing FTS v2 speedups, turbopuffer MCP beta, token matching, permissions guide, stopword change, and group_by increase

january changelog

tpuf.link/chlog

Python code snippet demonstrating a ContainsAnyToken filter with aggregate and filters fields for counting matching documents on an arbitrary BM25 query

new: ContainsAnyToken filter

return documents that match any token in the query string

faster than BM25 when you just need a binary match (e.g. "showing 36 of 131,072" in your search UI) as it skips score computation entirely

docs: tpuf.link/containsany

Rust code snippet showing before/after. HashMap lookup replaced by precomputed nested array access for faster range retrieval. before: HashMap lookup at each step in binary search self.sstables.get(table_id).unwrap().range after: precomputed in parallel vec self.level_ranges[i][j][k]

8.3% of query CPU in our largest (~4 TiB) tpuf namespaces was being spent on hash-map lookups to figure out which files might contain a key range

fix: precompute it in a flat array

trade memory for cache-friendly access → 8% faster puffin'

ANN v3: 200ms p99 query latency over 100 billion vectors Our latest ANN release supports scales of 100+ billion vectors in a single search index, with 200ms p99 query latency at 1k QPS and 92% recall.

tpuf ANN v3, for when you need to index the entire web

100B+ vectors @ 50ms p50 / 200ms p99 latency

blog: tpuf.link/ann-v3

BM25 queries use an inverted index: each search term maps to a posting list of matching document ids

tpuf now dynamically adjusts the encoding of postings lists based on density, like roaring bitmaps

result → up to 26% faster search for queries whose terms match many documents

turbopuffer December 2025 changelog 🧱 Redesigned inverted index structure for faster FTS queries 📤 New object storage-native indexing queue for up to 10x faster queue time 🔦 kNN exact search for 100% recall on filtered vector search queries 🪣 Return a max number of search results per attribute value using limit.per 🇨🇦 AWS ca-central-1 (Montreal) region 🌏 Cross-region backups guide 🤝 Link multiple orgs to a single account for unified billing, SSO, and roles [opt-in, beta]

december changelog

tpuf.link/chlog

Designing inverted indexes in a KV-store on object storage How we redesigned our inverted index structure using fixed-sized posting blocks to achieve 10x smaller indexes and dramatically better throughput.

for FTS v2, we redesigned our inverted index structure

• tighter compression
• less KV overhead
• better MAXSCORE interaction

up to 10x smaller indexes → up to 20x faster text search!

tpuf.link/fts-index

Why BM25 queries with more terms can be faster (and other scaling surprises) I analyzed how BM25 query latencies scale with document count and top_k. Longer queries scale less efficiently, and essential terms impact performance in some surprising ways.

we modeled BM25 query latency across varying term counts, document counts, and top_k values.

takeaways:
- sometimes longer queries are *faster*
- the longer the query, the less efficiently it scales
- fitted curves on raw data are immensely gratifying

tpuf.link/bm25-latency

Line chart showing max indexing queue wait times peaking near 30 minutes before dropping to steady ~1 minutes, with a max latency marker at 57.55s around 15:04:30

we rolled out a new indexing queue on all tpuf shared regions

~10x lower index queue time → new documents get indexed sooner → faster queries on new data with less WAL scanning

built entirely on object storage, no kafka

(chart: max create_index time in queue, gcp us-east4)

TELUS indexes 25,000+ AI copilots on turbopuffer serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

TELUS indexes 25,000+ AI copilots on turbopuffer

"This doesn't exist without turbopuffer. If we used a traditional search provider, our bill would be in the millions each year." - Justin Watts, Distinguished Engineer

tpuf.link/telus

new: phrase matching

use the ContainsTokenSequence in your tpuf FTS queries to match documents on an exact phrase

docs: tpuf.link/phrase-match

Query documents serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

docs: tpuf.link/aggregations

Python- code snippet showing a turbopuffer query building a filtered aggregation: sum of total_lines_of_code grouped by programming_language, then printing results.

new: Sum aggregate function

combine it with group_by and filters for olap-style puffin'

Vectorized MAXSCORE over WAND: building faster text search for humans and agents turbopuffer has improved text search performance up to 20x by adopting the same text search algorithm as Apache Lucene, a vectorized variant of block-max MAXSCORE

yesterday: short human queries, scalar CPUs
today: long LLM queries, wide SIMD lanes

for FTS v2, we use a vectorized MAXSCORE algorithm instead of WAND, because dumb & serial beat smart & random algorithms on modern CPUs

tpuf.link/maxscore

turbopuffer logo alongside playerzero logo, stats below: "18x faster", "1B+ documents", "25k+ namespaces" on a dark background.

PlayerZero's AI retrieves and reasons over code and logs to debug large codebases.

"We went from 3 minutes to <10 seconds, with much better recall, which means fewer agent loops." - Maria Vinokurskaya, Founding Engineer

tpuf.link/playerzero