Search in Practice

Measuring Search Quality

You can’t improve what you don’t measure. Track:

Click-through rate (CTR): what percentage of searches result in a click?

// Log search events
async function trackSearch(query: string, userId: string, results: SearchResult[]) {
  await db.query(
    `INSERT INTO search_events (query, user_id, result_ids, searched_at)
     VALUES ($1, $2, $3, NOW())`,
    [query, userId, results.map(r => r.id)]
  );
}

// Log click events
async function trackClick(query: string, userId: string, clickedId: string, position: number) {
  await db.query(
    `INSERT INTO search_clicks (query, user_id, clicked_id, position, clicked_at)
     VALUES ($1, $2, $3, $4, NOW())`,
    [query, userId, clickedId, position]
  );
}

// CTR query
const ctr = await db.query(`
  SELECT
    e.query,
    COUNT(DISTINCT e.id) AS searches,
    COUNT(DISTINCT c.id) AS clicks,
    COUNT(DISTINCT c.id)::float / COUNT(DISTINCT e.id) AS ctr
  FROM search_events e
  LEFT JOIN search_clicks c ON c.query = e.query
    AND c.user_id = e.user_id
    AND c.clicked_at > e.searched_at
    AND c.clicked_at < e.searched_at + INTERVAL '5 minutes'
  WHERE e.searched_at > NOW() - INTERVAL '7 days'
  GROUP BY e.query
  HAVING COUNT(DISTINCT e.id) > 10
  ORDER BY ctr ASC  -- lowest CTR = worst performing queries
  LIMIT 50
`);

Low CTR queries are your worst performers — users search, see results, click nothing. These are the highest-value queries to fix.

Mean Reciprocal Rank (MRR): how high is the clicked result?

// MRR = average of (1 / position of first click)
const mrr = await db.query(`
  SELECT AVG(1.0 / c.position) AS mrr
  FROM search_clicks c
  WHERE c.clicked_at > NOW() - INTERVAL '7 days'
    AND c.position <= 10
`);
// MRR of 1.0 = always clicking first result
// MRR of 0.5 = average first click at position 2

Zero-results rate: what percentage of searches return no results?

const zeroResults = await db.query(`
  SELECT
    query,
    COUNT(*) AS searches
  FROM search_events
  WHERE result_count = 0
    AND searched_at > NOW() - INTERVAL '7 days'
  GROUP BY query
  ORDER BY searches DESC
  LIMIT 50
`);

Zero-results queries reveal gaps: missing products, missing synonyms, or very specific queries that need fuzzy matching.

Synonyms

Users say “couch,” you have “sofa.” Users say “laptop,” you have “notebook computer.”

// Meilisearch synonyms
await index.updateSettings({
  synonyms: {
    'couch': ['sofa', 'settee', 'loveseat'],
    'laptop': ['notebook', 'portable computer'],
    'tv': ['television', 'monitor', 'screen'],
    'cellphone': ['mobile', 'smartphone', 'phone'],
  },
});

// Elasticsearch synonyms (more powerful — supports one-way and multi-way)
// In analyzer settings:
filter: {
  synonym_filter: {
    type: 'synonym',
    synonyms: [
      'couch, sofa, settee => couch',          // normalize to one term
      'laptop, notebook, portable computer',   // multi-way (bidirectional)
      'tv => television, tv',                  // expand tv to both
    ],
  },
},

Build synonyms from analytics — if users frequently search for X and click a result for Y, X and Y might be synonyms.

Query Rules (Curated Results)

Business-curated results that override relevance for specific queries:

// Meilisearch query rules
// Pin a specific product to position 1 for "macbook"
// (not directly supported in Meilisearch — use result boosting)

// Elasticsearch — pin documents at the top of results
const results = await es.search({
  index: 'products',
  query: {
    pinned: {
      ids: ['prod-123', 'prod-456'],  // always first
      organic: {
        multi_match: {
          query: 'macbook',
          fields: ['name^3', 'description'],
        },
      },
    },
  },
});

Implement query rules in a database table:

CREATE TABLE search_rules (
  id         UUID PRIMARY KEY,
  query      TEXT NOT NULL,       -- exact query to match
  action     TEXT NOT NULL,       -- 'pin', 'boost', 'hide', 'redirect'
  target_ids TEXT[],              -- for pin/boost/hide
  redirect   TEXT,                -- for redirect action
  priority   INT DEFAULT 0
);

-- When searching for "macbook" → pin prod-123 to top
INSERT INTO search_rules (query, action, target_ids)
VALUES ('macbook', 'pin', ARRAY['prod-123']);

Personalization

Boost results based on user behavior:

async function personalizedSearch(userId: string, query: string) {
  // Get user's preferred categories based on purchase history
  const preferences = await db.query(
    `SELECT category, COUNT(*) AS count
     FROM orders
     JOIN order_items USING (order_id)
     JOIN products USING (product_id)
     WHERE user_id = $1
       AND created_at > NOW() - INTERVAL '90 days'
     GROUP BY category
     ORDER BY count DESC
     LIMIT 5`,
    [userId]
  );

  // Build category boost function
  const categoryBoosts = preferences.rows.map((p, i) => ({
    filter: { term: { category: p.category } },
    weight: 3 - (i * 0.5),  // 3x, 2.5x, 2x, 1.5x, 1x
  }));

  return es.search({
    index: 'products',
    query: {
      function_score: {
        query: {
          multi_match: {
            query,
            fields: ['name^3', 'description'],
          },
        },
        functions: [
          ...categoryBoosts,
          // Also boost recently viewed
          {
            filter: { terms: { id: await getRecentlyViewed(userId) } },
            weight: 1.5,
          },
        ],
        score_mode: 'multiply',
        boost_mode: 'multiply',
      },
    },
  });
}

Personalization is powerful but adds latency (extra DB query per search). Cache user preferences for a few minutes.

A/B Testing Relevance

Don’t guess which ranking is better — measure it:

// Assign users to variants
function getSearchVariant(userId: string): 'control' | 'treatment' {
  const hash = parseInt(
    createHash('md5').update(userId).digest('hex').slice(0, 8), 16
  );
  return hash % 2 === 0 ? 'control' : 'treatment';
}

// Search with variant-specific settings
async function abSearch(userId: string, query: string) {
  const variant = getSearchVariant(userId);

  const searchParams = variant === 'control'
    ? { rankingRules: ['words', 'typo', 'proximity', 'attribute', 'exactness'] }
    : { rankingRules: ['words', 'typo', 'attribute', 'proximity', 'exactness'] };
  // Treatment: attribute before proximity — test if it improves CTR

  const results = await index.search(query, searchParams);

  // Log variant for analysis
  await trackSearch(query, userId, results.hits, { variant });

  return results;
}

// After 1 week: compare CTR between control and treatment
const comparison = await db.query(`
  SELECT
    variant,
    COUNT(DISTINCT e.id) AS searches,
    COUNT(DISTINCT c.id) AS clicks,
    COUNT(DISTINCT c.id)::float / COUNT(DISTINCT e.id) AS ctr
  FROM search_events e
  LEFT JOIN search_clicks c ON c.query = e.query AND c.user_id = e.user_id
  GROUP BY variant
`);

Handling “No Results”

Never show a blank “no results” page:

async function searchWithFallback(query: string) {
  // First: exact search
  let results = await index.search(query, {
    filter: ['in_stock = true'],
  });

  if (results.hits.length > 0) return { results, mode: 'exact' };

  // Fallback 1: relax filters
  results = await index.search(query, {});
  if (results.hits.length > 0) return { results, mode: 'relaxed_filters' };

  // Fallback 2: fuzzy / partial terms
  const tokens = query.split(' ').filter(t => t.length > 3);
  if (tokens.length > 1) {
    results = await index.search(tokens.slice(0, 2).join(' '));
    if (results.hits.length > 0) return { results, mode: 'partial_query' };
  }

  // Fallback 3: popular items in the queried category
  const popularItems = await db.query(
    'SELECT * FROM products WHERE in_stock = true ORDER BY popularity DESC LIMIT 20'
  );

  return {
    results: { hits: popularItems.rows },
    mode: 'popular_fallback',
    suggestions: await getSuggestions(query),
  };
}

Operational Checklist

□ Index monitoring: track index size, doc count, search latency
□ Zero-results monitoring: alert if > 10% of queries return 0 results
□ Sync monitoring: alert if Meilisearch lags database by > 5 minutes
□ Weekly: review bottom 50 queries by CTR
□ Monthly: review zero-results query list → add synonyms or missing products
□ After deploys: verify search still returns expected results (smoke test)
□ Search analytics dashboard: CTR, MRR, zero-results rate, query volume

// Smoke test after deploy
async function searchSmokeTest() {
  const testCases = [
    { query: 'laptop', expectedMinResults: 10 },
    { query: 'macbook pro', expectedFirstId: 'prod-123' },
    { query: 'iphone', expectedCategory: 'phones' },
  ];

  for (const tc of testCases) {
    const results = await index.search(tc.query, { limit: 1 });
    if (results.hits.length < (tc.expectedMinResults ?? 1)) {
      throw new Error(`Search smoke test failed: "${tc.query}" returned too few results`);
    }
  }
}