How would you design a search service with an inverted index instead of LIKE queries

package com.bank.search.antipattern;

public class LikeSearchWrong {

    // WRONG: full table scan on every search query
    public static final String QUERY =
        "SELECT * FROM products WHERE description LIKE '%home loan%'";
    // Problems:
    // 1. Leading wildcard -> no index used -> full table scan
    // 2. Runs on primary DB -> competes with live transactions
    // 3. Cannot rank by relevance
    // 4. Cannot handle typos
    // 5. Gets slower as data grows
}

package com.bank.search.engine;

import java.util.*;
import java.util.stream.Collectors;

public class SimpleInvertedIndex {

    // term -> set of document IDs
    private final Map<String, Set<String>> index = new HashMap<>();

    public void addDocument(String docId, String text) {
        for (String token : tokenize(text)) {
            index.computeIfAbsent(token, k -> new HashSet<>()).add(docId);
        }
    }

    public Set<String> search(String query) {
        String[] terms = tokenize(query);
        Set<String> result = null;
        for (String term : terms) {
            Set<String> postingList = index.getOrDefault(term, Set.of());
            if (result == null) {
                result = new HashSet<>(postingList);
            } else {
                result.retainAll(postingList); // intersection
            }
        }
        return result != null ? result : Set.of();
    }

    private String[] tokenize(String text) {
        return text.toLowerCase().split("\\s+");
    }

    public static void main(String[] args) {
        SimpleInvertedIndex idx = new SimpleInvertedIndex();
        idx.addDocument("P001", "Home Loan with low interest rate");
        idx.addDocument("P002", "Car Loan for salaried employees");
        idx.addDocument("P003", "Home Insurance plan");

        System.out.println("Search 'home loan': " + idx.search("home loan"));
        System.out.println("Search 'loan': " + idx.search("loan"));
    }
}

Search 'home loan': [P001]
Search 'loan': [P001, P002]

package com.bank.search.ranking;

public class RelevanceExplanation {
    // Document P001: title = "Home Loan", description = "...home loan..."
    // Document P003: description = "...mentions loan once in passing..."
    // Query: "home loan"
    //
    // P001 scores higher because:
    //   - "home" appears in title (boosted field)
    //   - "loan" appears in title AND description (higher TF)
    // P003 scores lower because:
    //   - "loan" appears once in description only
    //
    // LIKE cannot do this: it returns both as equal matches.
}

package com.bank.search.fuzzy;

public class LevenshteinDistance {

    public static int distance(String a, String b) {
        int[][] dp = new int[a.length() + 1][b.length() + 1];
        for (int i = 0; i <= a.length(); i++) dp[i][0] = i;
        for (int j = 0; j <= b.length(); j++) dp[0][j] = j;
        for (int i = 1; i <= a.length(); i++) {
            for (int j = 1; j <= b.length(); j++) {
                int cost = a.charAt(i - 1) == b.charAt(j - 1) ? 0 : 1;
                dp[i][j] = Math.min(dp[i - 1][j] + 1,
                    Math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost));
            }
        }
        return dp[a.length()][b.length()];
    }

    public static void main(String[] args) {
        System.out.println(distance("hoem", "home")); // 1 (swap e and m)
        System.out.println(distance("lon", "loan"));   // 1 (insert a)
        // Elasticsearch fuzziness=1 would match both
    }
}

1
1

package com.bank.search.sync;

public class ProductIndexer {

    private final ElasticsearchClient esClient;

    public ProductIndexer(ElasticsearchClient esClient) {
        this.esClient = esClient;
    }

    // Event-driven: consume ProductUpdated events from Kafka
    public void onProductUpdated(ProductUpdatedEvent event) {
        esClient.index("products", event.getProductId(), event.toDocument());
    }

    // CDC: Debezium reads the DB transaction log and streams changes
    // No application code changes needed, never misses a write
}

package com.bank.search.reindex;

public class ZeroDowntimeReindex {

    public void reindex() {
        // 1. Create new index: products-v2
        // 2. Bulk index all products from DB into products-v2
        // 3. Atomically swap alias: products -> products-v2
        // 4. Delete old index: products-v1
        // Clients always query the "products" alias, never a version.
    }
}

package com.bank.search.antipattern;

// WRONG: writing to Elasticsearch without a database backup
// If the index is corrupted, you lose data.
// The DB must be the source of truth; the index is a derived copy.