Search Architecture Overview

One of the most common architectural mistakes is using the wrong tool for data retrieval. Engineers reach for a database when they need search, or bolt search features onto a database that wasn't designed for them. The result is either slow queries, poor relevance, or complex workarounds that become maintenance nightmares.

The confusion is understandable. Both databases and search engines:

• Store data
• Accept queries
• Return results

But they are optimized for fundamentally different access patterns. Understanding these differences—deeply, not superficially—is essential for making correct architectural decisions.

This page will give you the clarity to answer: "Should I use a database query or a search engine?" with confidence.

Before comparing specific capabilities, let's understand the foundational differences in how search engines and databases are designed.

The Index Structure Divide:

The most fundamental difference is the underlying index structure:

B-tree (Database):

• Optimized for range scans and exact matches on indexed columns
• Efficient for queries like WHERE price BETWEEN 10 AND 50 or WHERE id = 123
• Poor for full-text search: WHERE content LIKE '%machine learning%' requires full scan

Inverted Index (Search Engine):

• Optimized for term lookup: "which documents contain 'machine' AND 'learning'?"
• Excellent for full-text search, fuzzy matching, relevance scoring
• Less efficient for arbitrary range queries on numeric data (though modern search engines add specialized indexes)

Let's compare specific query types and how each system handles them:

The most significant capability gap between search engines and databases is relevance ranking. Search engines are fundamentally designed to return results ordered by relevance—a concept foreign to traditional databases.

What is Relevance?

Relevance is the degree to which a result satisfies the user's information need. It's subjective, context-dependent, and multidimensional:

• Textual relevance: How well does the document match the query terms?
• Quality signals: Is this a high-quality, authoritative document?
• Freshness: Is this content recent and up-to-date?
• Personalization: Is this relevant to this user specifically?
• Popularity: Do other users find this useful?

Search engines compute relevance scores by combining these signals using sophisticated ranking algorithms.

Database Approach: Boolean Matching

-- Database returns unranked matches (or ordered by arbitrary column)
SELECT * FROM products 
WHERE title ILIKE '%headphones%' 
ORDER BY created_at DESC;  -- Ordered by date, NOT relevance

Databases return rows that match predicates, but they don't inherently understand "which match is better." You can add weights manually, but it's clunky:

-- Attempt at relevance scoring in SQL
SELECT *, 
  (CASE WHEN title ILIKE '%headphones%' THEN 2 ELSE 0 END +
   CASE WHEN description ILIKE '%headphones%' THEN 1 ELSE 0 END) AS score
FROM products 
WHERE title ILIKE '%headphones%' OR description ILIKE '%headphones%'
ORDER BY score DESC;

This approach:

• Doesn't consider term frequency
• Doesn't handle multi-word queries well
• Doesn't adapt to query length or document length
• Becomes unmanageable as complexity grows

Search Engine Approach: Scoring Functions

Search engines use well-researched scoring functions:

BM25 (Best Match 25):

score(D, Q) = Σ IDF(qi) × (tf(qi, D) × (k1 + 1)) / (tf(qi, D) + k1 × (1 - b + b × |D|/avgdl))

This considers:

• tf (term frequency): How often the term appears in this document
• IDF (inverse document frequency): How rare the term is across all documents
• Document length normalization: Longer documents don't get unfair advantage
• Tunable parameters: k1 and b can be adjusted for different use cases

Beyond BM25:

• Field boosting: Title matches score 3x body matches
• Function scores: Boost recent documents, popular items, in-stock products
• Personalization: Boost based on user history
• Learning to Rank: ML models trained on click data

Understanding performance profiles helps you predict system behavior and make capacity decisions.

Key Performance Insights:

1. Search engines win at text search, especially at scale

Inverted indexes make text search O(log n + k) regardless of corpus size. A database LIKE query is O(n)—it gets slower linearly with data size.

1 million products:
  Database LIKE: 500ms
  Elasticsearch: 10ms

100 million products:
  Database LIKE: 50 seconds
  Elasticsearch: 15ms

2. Databases win at transactional consistency

Read-after-write consistency is trivial in databases. In search engines, a document indexed now may not be visible for 1-5 seconds (configurable, but with trade-offs).

3. Databases win at complex relational queries

Multi-table joins, subqueries, window functions—databases have mature query planners optimized for these. Search engines don't even attempt them.

4. Search engines scale horizontally more naturally

Adding shards and replicas in Elasticsearch is configuration. Adding nodes to a PostgreSQL cluster requires careful architectural work (read replicas, partitioning, connection pooling).

One of the most significant differences is how each system handles data consistency and durability.

Practical Implications:

Scenario 1: E-commerce order

1. User places order (database INSERT)
2. Order appears in 'My Orders' immediately (database SELECT)
3. Order appears in search after refresh (1-5 seconds)

Acceptable: The critical transactional data is in the database. Search visibility lag is tolerable.

Scenario 2: Chat message

1. User sends message (database INSERT)
2. Message visible to recipient (database SELECT or real-time push)
3. Message searchable in history (search, after refresh)

Acceptable: Real-time delivery doesn't depend on search index.

Scenario 3: Financial trading

1. Trade executed (database, requires ACID)
2. Trade visible in portfolio (database, must be immediate and consistent)
3. Trade searchable in history (secondary concern)

Search is tertiary here. The database handles all critical paths.

Let's crystallize the decision into clear guidelines:

In practice, most systems combine databases and search engines. Let's explore common patterns for integrating them.

Pattern 1: Database as Source of Truth, Search for Queries

┌─────────────┐     Write      ┌─────────────┐
│   Service   │ ──────────────► │  Database   │
└─────────────┘                 └──────┬──────┘
      ▲                                │
      │ Search Query              CDC / ETL
      │                                │
┌─────┴─────┐                   ┌──────▼──────┐
│  Search   │ ◄──── Sync ────── │   Search    │
│  Results  │                   │   Engine    │
└───────────┘                   └─────────────┘

How it works:

1. All writes go to the database (ACID guaranteed)
2. Change Data Capture (CDC) or ETL syncs changes to search
3. Search queries go directly to search engine
4. Detailed lookups may go back to database

Pros: Clear separation of concerns, each system does what it's best at Cons: Sync latency (seconds to minutes), sync complexity

Implementation options:

• Debezium for CDC from PostgreSQL/MySQL to Kafka → Elasticsearch
• Application-level dual-write (careful: can diverge)
• Periodic full reindex (simple but slow)

Pattern 2: Search for Discovery, Database for Details

User searches "blue Nike running shoes" → Elasticsearch
  ↓ Returns [product_id: 123, 456, 789] with scores
  
User clicks product 123 → PostgreSQL
  ↓ Fetch full product details, inventory, reviews
  
User adds to cart → PostgreSQL
  ↓ Transaction: update cart, check inventory

Search handles the "needle in haystack" problem; database handles transactional operations and detailed retrieval.

Pattern 3: Search IDs, Database for Consistency

Search: "available flights SFO → NYC" → Elasticsearch
  ↓ Returns candidate flight IDs based on text/facet match
  
Filter: Check real-time availability → PostgreSQL
  ↓ Database has authoritative seat counts
  
Book: Reserve seat → PostgreSQL
  ↓ Transaction with row locks, ACID guarantee

Search narrows candidates; database provides consistent state for booking.

Pattern 4: Polyglot Persistence

Different data stores for different access patterns:

┌─────────────────────────────────────────────────────────────────┐
│                        Application Layer                        │
└───────────────────────────────┬─────────────────────────────────┘
                                │
        ┌───────────────────────┼───────────────────────┐
        ▼                       ▼                       ▼
┌───────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   PostgreSQL  │     │  Elasticsearch  │     │      Redis      │
│  Transactions │     │     Search      │     │     Caching     │
│     OLTP      │     │   Full-text     │     │    Sessions     │
└───────────────┘     └─────────────────┘     └─────────────────┘

Each store is optimized for its access pattern. The application orchestrates.

Learning from common mistakes helps you avoid costly architectural decisions:

Case Study: The Stale Search Problem

Scenario: E-commerce site. User updates product inventory to 0 (sold out). Customer searches for product, sees it, tries to buy, gets error "out of stock."

Root cause: Database updated, but search index hasn't refreshed yet. Customer sees stale data.

Solutions:

1. Accept latency, improve UX: Show "availability may have changed" message. Check DB at cart/checkout.
2. Force refresh on critical updates: After setting inventory=0, force search refresh (expensive, use sparingly).
3. Real-time inventory overlay: Search returns candidates; a fast inventory service filters unavailable items before display.
4. Don't index inventory: Keep volatile fields in fast cache/DB, not in search. Search for discovery, DB for availability.

We've explored the fundamental differences between search engines and databases. Let's consolidate the essential guidance:

The Decision Heuristic:

Does the query involve:
  ├─ Free-form text matching? → Search Engine
  ├─ Relevance ranking? → Search Engine  
  ├─ Faceted filtering + aggregation? → Search Engine
  ├─ Transactions / ACID? → Database
  ├─ Multi-table joins? → Database
  ├─ Strong consistency? → Database
  └─ Both categories? → Hybrid (both)

Module Complete:

You've now completed the Search Architecture Overview module. You understand search system components, the indexing vs querying paths, inverted index internals, and how search engines differ from databases. This foundation equips you for the subsequent modules: full-text search techniques, Elasticsearch deep dive, indexing strategies, relevance tuning, and autocomplete implementation.