If someone cannot find an item on your site, start with the search they typed and the item they expected to see. The fix could be an index, a missing product attribute or a better ranking rule. Paying for a separate search engine before you know which of those failed may leave you with the same bad results and another system to maintain.
For example, a parts catalogue might need to match an exact model number, handle a misspelt brand, and show compatible parts first. The model number should probably match exactly. The brand may benefit from a forgiving match. Compatibility depends on information that must be present in the catalogue. A vendor demo that finds a misspelling proves only one of those things.
If you are scoping an ecommerce build or replacing search in an existing web app, use the same representative searches to compare your current platform, a Postgres approach and any specialised engine you shortlist. Here is what to ask each option to prove.
What can Postgres search do on its own?
PostgreSQL can search words in text, rank matches and apply the ordinary filters you already use in your database. The system turns source text into a searchable representation and interprets queries using a text search configuration. That configuration matters: language rules can normalise different forms of a word and ignore some common words. Use exact lookup for identifiers such as order numbers and SKUs rather than sending them through the same language rules as a paragraph of product copy.
The PostgreSQL text search index guide identifies GIN as the preferred index type for full-text search. That can help the database find candidate rows, but the index does not choose which result should come first. Weighting a match in the title above one in a long description is a separate decision. Try clean, structured fields and reasonable weights before assuming ranking requires another service.
The PostgreSQL trigram extension offers similarity matching and supports relevant indexes. It can help when someone mistypes a name, but similarity is not the same as knowing whether two parts are interchangeable. Treat fuzzy matching as a fallback where appropriate. If an exact SKU exists, a near match should not outrank it. Test short queries and codes separately from names; what helps one may make the other noisier.
For staff looking up recent orders, customer names or ticket subjects, this may be all you need. Search can read the same authoritative records and apply the same access rules as the rest of the app, provided your queries enforce them. You avoid copying sensitive records to another service. The tradeoff is that your team owns the query design and the database workload. Test search with ordinary writes happening alongside it, especially if you return live filter counts.
What would a dedicated engine change?
A dedicated engine is worth testing when the missing capabilities are specific: responsive suggestions as people type, filters with counts, typo handling or relevance rules that a merchandising team can adjust. There is no catalogue size at which those become mandatory. A small catalogue with inconsistent names may be much harder to search than a large one with reliable model numbers.
| Option | A reason to try it | What to prove in a trial |
|---|---|---|
| PostgreSQL | Search must respect existing database filters, and the team needs word and identifier matching more than merchandising controls. | Show good results and acceptable response times under normal app load. Verify exact identifiers and the fields allowed for each account. |
| Algolia | You want a hosted service with controls for typo tolerance. | Use representative product names and codes. Check how the settings handle both, and how operators can tell when an update is searchable. |
| Meilisearch | You want a dedicated index and want to assess how it fits your catalogue update process. | Verify the relevant search settings on your data, and track a submitted indexing task until it succeeds or fails. |
| Typesense | You want to test built-in typo tolerance, prefix search and facets against your Postgres implementation. | Measure the actual filters and result quality, including whether customers can still find a precise part while typing an incomplete query. |
A hosted trial should include representative data and permissions, without copying customer records you do not need. Give each option the same expected results rather than picking a tool after a polished sample search. If your platform already offers a suitable catalogue search, test that before you add custom infrastructure. This is about search inside the app; it does not replace your site's public SEO.
How do you tell whether results are getting better?
Build a small, labelled test set. Use sanitised search logs, questions staff actually answer or examples collected in discovery. For each, write down the result or type of result a customer should see first. Mix exact model numbers, product categories, alternate spellings, regional terms, incomplete queries and searches that should return nothing. Include different word orders and units when those affect the meaning. A good score on broad product names can hide a serious problem with parts that vary by size or fit.
Check the entire result, including ordering and filters. For example, a customer may find the right type of charger but only see an incompatible wattage after selecting a brand. Verify the product attributes before tuning the engine. Ask someone familiar with the products to score the top results. Time the same queries on a representative phone connection and look beyond one fast request: the buyer experiences the wait from typing to usable results, not just the search server's response time.
Agree on what counts as an improvement before comparing quotes. You might require that every exact model number in your test set leads to the corresponding product when it is available. For vague category terms, let the product team agree on a reasonable list of matches. Keep cases with no results: sometimes the honest answer is that you do not sell that item. Avoid forcing broad matches just to improve a zero-results metric.
Run the first comparison with the same data and defaults, then allow each option a clearly bounded round of tuning. Record what was changed and why. A demo driven by manual rules for your favourite five products can look excellent and still fail on the next batch of queries. Keep a second set of examples aside until the end. If a proposed tuning change fixes the original examples but makes the unseen ones worse, you have learned something useful before signing a contract.
Who owns the index when a product changes?
Keep an authoritative record for price, publication state and availability. A separate engine normally searches a copy shaped for search, so an update to the source and its appearance in results are two different events. For instance, Algolia documents that indexing writes are asynchronous. Measure when changes are visible, rather than treating acceptance of the update as completion.
Decide who can see a failed update and how the app recovers from it. Test a price change, a discontinued listing and a change in who may see an item. Include suggestions and facet counts in the access review, not just the final detail page. A removed item should not keep appearing without someone knowing. Checkout should still use the current source data to validate what can actually be sold. Your quote should name the person or team that owns the sync, how a rebuild is done, and how you switch back if an index update goes wrong.
Do not estimate from record count alone. Record how the app sends requests during a typical session, including suggestions and filter changes; a single customer search can generate more than one request. Then price the applicable plan with that workload, the expected index size, update frequency, and any environments you need. Include the time to tune results and maintain the feed. Self-hosting moves the responsibility for upgrades, capacity and recovery to your team. It does not make those responsibilities disappear.
When should you keep the search you already have?
Keep it if the main problems are missing attributes, inconsistent names or an exact lookup that has not been built. Those are changes you can test without starting a migration. Do not pay for typo tolerance as a substitute for updating the catalogue, and do not introduce suggestions just because you can. If each keystroke leads to a slow or costly request, test a simpler interaction such as waiting until the user has entered enough text to make a useful search.
If the existing approach cannot meet your agreed relevance and response goals at representative load, try a dedicated engine behind one search surface before moving everything. Keep the trial small enough that you can compare the same queries, check index freshness and reverse the change. Add the integration and maintenance work to the website development budget rather than comparing only subscription prices.
If you are weighing those options, share a few searches your users struggle with, without customer names or private records. The first useful conversation is about what each query should return and how you will know it got better.
Bharat Vasireddy
Founder & Digital Marketing Strategist8+ years of experience in performance marketing and web development. I help businesses scale through data-driven SEO, Google Ads, and high-performance websites.