As part of the US antitrust trial against Google, the (very juicy) testimonies of two key figures on Google's Search team have been made public: Hyung-Jin Kim (HJ Kim), one of the main engineers behind Google's search ranking system (and the creator of Navboost), and Pandu Nayak, VP of Search at Google. Both shared details we had never seen before and gave us more insight into how results ranking is structured internally in Google Search.
Their testimonies reveal how Quality (Q) and Topicality (T) are defined and calculated, and also how these signals are integrated with Google's deep learning models. They also show the problems this architecture creates for Google when it comes to reverse engineering. In this article I'll analyze both documents, which will help us better understand how the world's most important search engine works and what it means for SEO professionals and anyone curious about information retrieval (IR).

1. Signals are more manual than we thought
Except for a few signals based on language models (RankBrain, DeepRank), most of the signals Google uses to rank results are hand-crafted. In practice, this means that for most signals, Google engineers apply mathematical functions (like sigmoids) to observed data (content, links, user behavior, human ratings) and set the right thresholds through regression or manual tuning.
The reason for this manual design is that it lets Google step in and debug the system when it spots unwanted behavior or anomalies, because they can trace errors more easily. That's why Google sees this approach as a competitive advantage over other search engines like Bing, which doesn't work this way. And thank goodness many of them are manual, because one of the things Google Search engineers complained about at the Web Creator Conversation Event (the meeting Google held with about 20 independent publishers in October 2024) is that they don't know how to fix their algorithms. In other words, they admitted they couldn't explain why quality sites not only fail to rank, but get completely filtered out by their classifiers.
2. Quality (Q*) and Topicality (T*), the foundation of ranking
The two main signals in the ranking system are Q* (Quality) and T* (Topicality). Q* measures the perceived quality of a web page, and T* measures its relevance to the query.
Quality (Q*, pronounced "Q star") is a mostly static signal, and it's tied to domains rather than individual URLs. It's calculated per domain or group of pages and is made up of multiple sub-signals such as PageRank, domain authority, perceived trustworthiness, popularity (they mention they get it from Chrome), historical reputation and content structure. Although it's stable, it can include query-specific information when the system detects that the intent needs a higher level of specificity (for example, when a technical query needs to be steered toward sites with proven expertise). This system was developed in response to the rise of content farms, and it has evolved since then to deal with new threats, like automatically generated AI content.
PageRank feeds into Q* as one of its inputs, and Google acknowledges that Q* is still one of the signals with the biggest impact on how users perceive results, and also one of the easiest to replicate if Google's internal logs were exposed (which is what the DOJ is asking for). In other words, because Q* is so stable, a competitor who knew its logic could easily reverse engineer it.
Topicality (T*, T star), on the other hand, is a dynamic signal made up of three basic elements they call the ABC:
- Anchors (A): incoming links from other pages.
- Body (B): the text content of the page.
- Clicks (C): past user behavior, including how long users stayed on the page before going back to the SERP.
This ABC structure gives them a framework for calculating the document's semantic relevance to the query, and these signals are then linked to Navboost. Remember that Navboost measures how users interact with certain documents for specific queries, taking into account variables like location, device type and time (the last 13 months), and these are combined into a relevance score. Navboost is not a machine learning algorithm; it's a table that holds user behavior data for each URL.
A while ago, while looking into how this might be calculated, I came across a Chinese patent (2015) that explains how Navboost would work (but applied to video ranking). You can't imagine how happy I was to see that what HJ Kim describes is very similar to this formula I had saved, which I'm sharing below:
navboost = a * normalized(long_click_count) + b * normalized(long_click_rate)
Where:
- long_click_count is the number of times users clicked and stayed on the document for a significant amount of time after a given query. In other words, not every click counts, only the ones that involve actually consuming the content.
- long_click_rate is the ratio of long clicks to the document's total impressions for that query (a kind of adjusted CTR).
- a and b are the weights assigned to each Navboost component, and they must add up to 1.
final_score = α * topicality + β * quality + γ * navboost
Where:
- topicality is the document's relevance to the query. It's based on signals like content (body), links (anchors) and user behavior (clicks), what Google calls the ABC system.
- quality is a measure of the document's quality or trustworthiness, based on signals like perceived authority, historical reputation, content structure, and PageRank.
- navboost is a signal based on past user behavior: it measures how users interact with a document for a specific query.
- α, β, and γ are weights that indicate how much each of these signals influences the final score. They're parameters that are either set manually or learned through training, and they must add up to 1 (α + β + γ = 1).
That said, even though the formula is a sum, the result isn't linear in the raw signals: before they're combined, each signal goes through curves that adjust its impact based on its value, which we'll look at later.
Building topicality has been one of the longest and most complex projects in Google Search. Kim says it was under active development for many years, but there have been fewer structural changes in the last five years.
They also explained again that they use RankEmbed, which is simply a newer approach based on LLMs. It's a dual encoder system that generates embeddings for both queries and documents, and calculates how well they match using vector similarity. They say it's extremely efficient for common queries, but it has limitations in the long tail. According to Nayak, it was trained on just one month of data, which is again a problem, since third parties could replicate it if they had access to enough real or synthetic examples.
3. Calculating curves, Tangram and diversification
As I mentioned, signals aren't applied directly or linearly. Instead, Google uses curves to adjust how each signal responds across different ranges. For example, a signal like the number of times a term appears in the content doesn't keep increasing relevance forever; there's a saturation point, and curves make it possible to model it. In other words, these curves:
- Are used to control the impact of extreme values.
- Let the same signal behave differently in different contexts.
- Are tuned manually or through internal validation.
This approach applies not only to raw signals but also to combinations of topicality and quality. Some static signals are stored in the index itself for easier access, while dynamic signals, like query-based ones, are calculated in real time. For efficiency, some dynamic signals are temporarily stored in auxiliary tables. This mixed approach (direct storage vs. real-time computation) lets them balance latency and personalization.
In fact, for sensitive queries (like mental health topics), Google tunes thresholds, weights and curves very carefully to control what kind of information is shown. One example is the feature known as the "suicide box" (the helpline box shown for suicide-related searches).
As for SERP features, Google doesn't just rank classic web results (the 10 blue links); it also decides when to show blocks like knowledge panels, carousels (like Top Stories; I explained how it works here), images... To apply ranking to these modules, HJ Kim led the creation of Tangram (formerly called Tetris, which we've also covered on this blog), a system that applies search principles (ranking, triggering, diversity) to each component of the results.
Each of these features has its own triggering curves, rules, weights and contextual conditions. AI Overviews (AIO) are one example.
4. Hierarchical structure and signal combination logic
Google organizes its signals into "buckets" (logical groupings). For example, there's a quality bucket, a topicality bucket and a Navboost bucket (user navigation signals). Top-level signals are built as linear combinations (usually of the logarithm of the raw signals), with the requirement that their impact be monotonic. In other words, the higher the signal's value, the higher the perceived relevance or quality.
Internally, each document's scores can be viewed in debugging tools that include:
- semantic query expansion
- entity decomposition
- a table of scores per signal
- side-by-side document comparisons
These systems make it possible to see why one document ranks above another, and to make controlled adjustments if they find a bug or an opportunity for improvement. Very manual, as I said earlier. For example, Nayak mentions a case involving Holocaust denial in the SERPs, where Google adjusted its system so that reliable sources get absolute priority on sensitive queries.
5. Twiddlers, diversity adjustments and signal removal
Another manual and little-known part of the pipeline is Twiddlers (which I've been talking about for years), components that re-rank results after the main system has selected them. They're used to apply diversity policies, semantic coverage or result fine-tuning. For example, preventing all the results from coming from the same source when there are plenty of relevant alternatives.
Google also removes ranking signals when they:
- Lose effectiveness (due to changes in how the ecosystem behaves).
- Introduce systematic biases (like reinforcing rankings based on position).
- Are outperformed by more efficient or robust signals.
The classic example is the CTR signal: they found it was biased by position in the SERP (just as I pointed out 10 years ago), so it was replaced by an adjusted version that compensated for that bias (based on the impression slot).
6. User data and QD tables
As we already know, many of Google's modern signals are fed by interaction data, what Google calls User-Side Data, and which they've denied using ad nauseam. This data includes:
- Clicks on results.
- Time spent on the page.
- Bounces (pogo-sticking).
These signals are highly correlated with user preferences and are used to feed systems like Navboost. All this data is then stored in QD (query-to-document) tables, which allow lookups in both directions. In other words, given a document you can find out which queries trigger it, and given a query, which documents answer it best.
7. From classic IR to LLM-first
Historically, Google used BM25-style functions for ranking, and they very likely still do. The reason is that BM25 is very cheap for fast relevance calculations (that's how I saw Yandex doing it when I analyzed the leaked code of their algorithm), and it solves TF-IDF's problems with long texts. Later, Google integrated ML models (RankBrain, DeepRank) that served as additional predictors. DeepRank (eDeepRank, as they call it internally), for example, uses BERT and can be broken down into traditional signals. The current strategy is to combine classic signals with signals derived from ML models, which gives them the best of both worlds: interpretability and semantic coverage.
At the same time, Google is "rethinking its stack" from scratch with an LLM-first approach, which would mean redefining the role of each component: retrieval, ranking, SERP presentation and personalization. One of the challenges is the computational cost of LLMs, which varies depending on the use case (e.g., instant answers vs. re-ranking). We're already seeing this play out with AI Overviews.
8. What can we learn from this?
These documents confirm that, at least on paper, a good part of Google's ranking system is still very much hand-crafted. Most signals seem to be manually maintained, calibrated with functions designed by engineers and, in theory, debuggable. This would let them step in with surgical precision when something breaks.
But I think this narrative clashes with today's reality. Since the Helpful Content Update and other core updates, we've seen the system behave erratically and with a bias toward authority, filtering out quality sites without the engineers themselves being able to explain or reverse the effects. They've admitted it themselves, publicly and recently. So even if the architecture is designed to be traceable, in practice the scale, the interdependence between signals and the opacity some models introduce mean that this control has become partial, if not illusory.
At the same time, we can't ignore that they're moving forward and redesigning their architecture toward a more LLM-first approach. Not to replace everything that came before, but to extend it. Does this mean traditional practices are no longer valid? Not at all, and here's why.