Autocomplete and typo tolerance for Indian ecommerce search

Why Indian product naming breaks search

Indian ecommerce search fails for a simple reason: people do not name the same thing the same way. The same product can be typed in English, Hindi, Tamil, or a mix, and each region has its own everyday words.

A shopper might search for “atta”, “aata”, “gehu ka atta”, or the brand name only. Another person types “jeera”, “zeera”, or just “cumin”. If your catalog has only one of those forms, a very normal query can return nothing.

Small spelling differences hurt more than you expect because search engines often treat the query as exact text. One missing vowel, an extra space, or a different order of words can push the right product out of the top results, or into zero results.

Common reasons Indian product names split into many versions:

• Multiple scripts and transliterations (Hindi written in English letters, local spellings)
• Regional terms for the same item (food, clothing, household items)
• Brand-first vs generic-first naming (“Surf Excel 1kg” vs “detergent powder”)
• Abbreviations and spoken forms (“kurti” vs “kurta top”, “1 ltr” vs “1L”)
• Keyboard typos and autocorrect (“pista” becoming “pita”, “saree” vs “sarri”)

Autocomplete and typo tolerance change what the shopper experiences. Autocomplete reduces effort by guiding people toward the wording your store understands, before they hit search. Typo tolerance prevents “almost right” queries from failing, so shoppers still see relevant items even when the spelling is imperfect.

The practical goal for autocomplete and typo tolerance for Indian ecommerce search is not “perfect language support”. It is measurable: fewer zero-results searches and faster product discovery, so more shoppers reach a product list instead of a dead end.

Key ideas in plain language

Good search in India is less about fancy algorithms and more about understanding how people actually type product names. Many shoppers mix English with local words, spell the same thing three different ways, and expect search to still “get it”.

Autocomplete is the part that helps before the query is finished. As someone types “jeer…”, you can suggest “jeera rice”, “jeera powder”, or “jeera whole”. Done well, autocomplete reduces effort and gently nudges shoppers toward terms that exist in your catalog.

Typo tolerance means you still match when the user makes a likely mistake, like “zeera” vs “jeera” or “shampo” vs “shampoo”. The goal is to fix common errors without changing the meaning. Too much typo tolerance creates weird matches (for example, a short query like “ram” suddenly matching unrelated products).

Synonyms are simple: different words, same intent. “Atta” and “wheat flour” should land on the same set of products. In Indian ecommerce, synonyms often include brand-like terms (“biscuit” vs “cookies”), regional words, and category nicknames.

Transliteration is when people type Indian-language words using English letters. Someone might type “namkeen”, “nimeen”, or “namkin” depending on habit and keyboard. Transliteration rules help you match these variations, even if your catalog uses only one spelling.

A practical way to think about autocomplete and typo tolerance for Indian ecommerce search is this:

• Autocomplete guides the user toward a valid, popular query.
• Typo tolerance saves the user when they misspell a valid query.
• Synonyms connect different words to the same shopping intent.
• Transliteration connects different spellings to the same local-language term.

Once these are clear, you can build a small, controlled mapping set and expand it using real search analytics, instead of guessing.

Build your Indian naming dictionary (inputs to collect)

A good search dictionary starts with your own data, not guesswork. The goal is simple: capture how people actually name products in India, including local terms, spellings, and shorthand, so autocomplete and typo tolerance for Indian ecommerce search has something solid to work with.

First, mine your catalog. Product titles, category names, attributes, variant labels, brands, pack sizes, and units often contain the “official” wording shoppers should be able to reach. For groceries, this may include both generic and specific terms like “toor dal”, “arhar dal”, and “split pigeon peas” if you use them.

Next, collect real customer language. Search logs show what people type when they are in a hurry, while customer support chats reveal how they describe items when they cannot find them. Even a few weeks of logs can surface repeated patterns like “aata/atta”, “dahi/curd”, or “chilli/chili”.

Build inputs from five places, then merge and clean them:

• Catalog text (titles, attributes, variants, brands, sizes)
• Search queries (including zero-results queries)
• Customer support chats and call notes
• Regional and local terms your team already uses
• Unit and bundle shorthand (ml, ltr, pcs, combo, 1+1)

Finally, separate generic terms from brand terms. “Atta” should match many products, while a brand name should not accidentally pull results for unrelated items. Keep two labeled lists (generic vs brand) so later rules do not blur intent and confuse ranking.

Step-by-step: create a synonym and transliteration plan

Start small. Pick 20 to 50 categories that drive most searches and revenue, like staples, beauty, and popular electronics. This keeps the work focused and helps you see impact fast in autocomplete and typo tolerance for Indian ecommerce search.

Then build one shared “naming table” that everyone can edit (merch, content, support). Keep it in a spreadsheet first, then sync it into your search index.

1) Make a canonical list

For each category, choose the one term you want the system to treat as the “main” name (canonical). Use what customers recognize, not what the supplier calls it.

Create rows like this:

Add units and pack patterns as separate, reusable tokens: 1kg, 500 g, 2x, combo pack, family pack. These often cause zero-results because users type the whole thing.

2) Set strict “same product” rules

A synonym should mean the customer will be happy with the same results. Write a short rule that your team can follow:

• Allowed: regional name variants, brand-shortcuts, common spellings
• Allowed: Hinglish transliteration where meaning stays the same
• Not allowed: adjacent products (cleanser vs toner, cumin vs carom)
• Not allowed: different sizes as synonyms (size is a filter)
• Not allowed: “healthy” or “premium” as a synonym for the base item

3) Keep it easy to maintain

Assign one owner per category and add a simple review cadence (weekly at first). When support sees “couldn’t find” complaints, they add terms to the table the same day.

If you’re building this into a custom search stack, a vibe-coding tool like Koder.ai can help you ship the admin screen and syncing workflow quickly, while keeping the synonym list editable for non-technical teams.

Design autocomplete that feels right for India

Autocomplete should feel fast, familiar, and forgiving. For Indian ecommerce search, the biggest win is getting useful suggestions on the first few letters. People often type quickly, switch between English and local terms, and don’t remember exact spellings.

Start by tuning for prefixes. The first 2 to 4 characters should already show strong, high-intent suggestions. If someone types "sha", don’t waste the top slots on rare items. Show what most shoppers mean, and what you actually sell in depth.

Make suggestions category-aware, not just word-aware. If the user types a local term like "shakkar", suggestions should clearly point to the product category (sugar) and popular subtypes you carry (powdered, organic, etc.). This reduces confusion and cuts the chance they pick an unrelated result.

Keep suggestions short and readable. A good pattern is: brand + product (when it’s truly common) or product + key attribute. Avoid stuffing sizes, long model numbers, and multiple attributes into one line.

Here are practical UI rules that usually work well:

• Show 5 to 8 suggestions max, with the top 3 optimized for high conversion.
• Normalize spacing and punctuation, so "t-shirt", "tshirt", and "t shirt" lead to the same suggestion set.
• Prefer items and categories you can fulfill now (in-stock and active listings).
• Mix types carefully: 1 to 2 category suggestions, then products, then brands.
• Don’t show suggestions you cannot sell (no dead categories, no discontinued brands).

Example: a shopper types "dett". In India, many people mean "Dettol" (brand intent), but some want "handwash" or "sanitizer" (product intent). Your autocomplete can show "Dettol Handwash", "Dettol Sanitizer", and a category like "Handwash" so both intents are covered without guessing too hard.

When you do this consistently, autocomplete and typo tolerance for Indian ecommerce search becomes less about clever algorithms and more about giving shoppers the next obvious step.

Set typo tolerance without messy matches

Typo tolerance helps people find products even when they mistype. But if you make it too loose, search starts showing “close enough” items that feel wrong. The goal is simple: catch obvious mistakes, and be cautious when the intent could change.

Start with safe edit-distance rules based on word length. Short words break easily, so keep them strict. Longer words can handle a bit more flexibility.

• 1-4 letters: allow 0-1 edit (example: “atta” -> “atta”, “atta” -> “attta”)
• 5-8 letters: allow up to 2 edits
• 9+ letters: allow up to 3 edits
• If a query has multiple words, apply edits per word, but cap the total edits for the whole query

Treat numbers as a separate class. “1kg” and “10kg” should never be interchangeable, and “500ml” should not become “1500ml”. A practical rule is: do not apply typo tolerance inside numeric tokens, and do not change units. Only allow formatting fixes like spaces or lowercase (“1 kg”, “1KG”, “1kg”).

Protect brand names and high-intent terms from being “corrected” into generic words. Keep a small protected list (top brands, private labels, and common brand-like queries). If a query matches a protected term closely, prefer showing a suggestion instead of rewriting it.

Keyboard-neighbor mistakes are common on mobile, especially with Hinglish. Add extra tolerance for nearby keys (a-s, i-o, n-m), but only when the rest of the word is a strong match.

When the correction is ambiguous, show it as a suggestion, not a silent replacement. For example, if “dove” could become “done” or “dovee”, show “Did you mean dove?” and keep the original results visible. This keeps trust high and reduces angry back-clicks.

Transliteration and local language terms (practical rules)

Indian queries often mix scripts and habits in one line: “जीरा rice”, “jeera चावल”, “zeera rice”, or “poha nashta”. Your search should treat these as the same intent, not separate worlds. For autocomplete and typo tolerance for Indian ecommerce search, the goal is simple: map many ways of writing a product name to one clean product meaning.

Start with a small, practical set of rules and grow it only when you see it working.

Practical normalization rules

• Accept script mixing by normalizing everything into a shared “search form” (keep the original query for analytics, but match against a normalized version).
• Add transliteration pairs only for your top items first (for example: namkeen, bhujia, poha, jeera). Include common spellings users actually type.
• Handle long vowel variants as explicit pairs where they matter (poha vs pauha, jeera vs zeera), instead of trying to guess every vowel shift.
• Use sound swaps carefully and narrowly: v-w, b-v, j-z. Apply them only on known product tokens, not on the whole query, to avoid weird matches.
• Keep brand names and SKUs mostly “as typed” so you do not accidentally rewrite them into something else.

Which languages to support first

Pick based on traffic and zero-results, not on ambition. A common order is English plus Hinglish first, then add Hindi script if a meaningful share of queries use it. If you later see demand in one region, extend with the next language in your logs, one category at a time.

Analytics loop: improve search based on real behavior

Search quality is not a one-time setup. Treat it like a weekly habit: watch what people type, what they click, and where they give up. That is how autocomplete and typo tolerance for Indian ecommerce search gets better without guesswork.

Start with a small set of core metrics and keep them consistent across weeks:

• Zero-results rate (overall and for top queries)
• Refinement rate (users retyping or adding filters right after searching)
• Add-to-cart after search (or product clicks after search if carts are noisy)
• Autocomplete usage (suggestion clicks vs full manual typing)
• Correction impact (typo-fixed queries that lead to clicks vs bounces)

Once a week, pull your top no-result queries and classify each one. Keep categories simple so teams actually use them: missing synonym (jeera vs zeera), spelling variation, brand or model mismatch, wrong language or script, or catalog gap (product not stocked). The goal is to separate "search needs a synonym" from "inventory is missing".

Autocomplete data is often the fastest win. If users frequently ignore suggestions and finish typing, your suggestions may be too generic, in the wrong order, or missing local terms. If they click suggestions but still refine or bounce, the suggestion may look right but lead to weak results.

Typos need an audit, not just a higher tolerance. Sample 20-50 corrected queries per week and mark them as:

• Helpful (fixed to the intended product)
• Harmless (close enough, user still found items)
• Harmful (fixed to a different product or category)

Put this into a simple dashboard view that product and marketing can read in 2 minutes: top zero-results queries with the assigned cause, top autocomplete suggestions and click rate, and a short list of actions for the next release. If you build internal tools quickly (for example, in Koder.ai), this dashboard and the weekly export pipeline are good first projects.

Common mistakes and traps to avoid

Most search problems in India are not about “more synonyms”. They come from a few predictable mistakes that slowly push people to the wrong results and hurt trust.

One of the biggest traps is using over-broad synonyms that merge different products. If “cream” and “lotion” become interchangeable, people who want a thick face cream may land on a light body lotion, then leave. Keep synonyms tight: map variants of the same intent, not neighboring categories.

Another common miss is pack size and unit intent. “Oil 1L” and “oil 5L” are not the same shopping mission, and neither are “atta 5 kg” and “atta 10 kg”. If your rules ignore units, a user trying to restock in bulk can get small packs, and your ranking looks random.

Here are high-impact mistakes to watch for:

• Treating close products as synonyms (cream vs lotion, shampoo vs conditioner)
• Ignoring size, count, and unit words (1L, 5L, 500 ml, 10 pcs)
• Letting typo tolerance “fix” brand names into other brands
• Showing autocomplete suggestions you do not stock or cannot deliver to that pin code
• Setting and forgetting rules, especially after promos and seasonal spikes

Brand names need extra care. If someone types “Himalya face wash” and your typo settings “correct” it to a different brand that happens to be popular, it feels like bait. A safer rule is: be forgiving on generic words (“shampu”), but stricter on brands and model-like tokens.

Autocomplete can also backfire when it suggests unavailable items. For example, suggesting “ghee 2L” because it is a frequent query, even though only 1L is in stock, creates disappointment. Prefer suggestions that you can actually fulfill today.

If you are building autocomplete and typo tolerance for Indian ecommerce search, add a review habit: after a sale week, check new top queries, rising misspellings, and zero-results terms. Even small season shifts (wedding season, monsoon, exam season) can change what people type.

If you want to test these rule changes quickly, Koder.ai can help you prototype a search rules service and an admin page to manage synonyms, units, and brand protections, then export the code when you are ready.

Realistic example: fixing “jeera rice” and “zeera rice” searches

A shopper types “zeera rice” and gets zero results. They are not looking for a different product. They meant “jeera rice” (cumin rice), but they spelled it the way they say it.

You fix this with two small, safe changes: a synonym for common spelling variants and a conservative typo rule. For this query, treat “zeera” as a transliteration variant of “jeera”, not as a separate meaning.

Here’s a practical mapping that usually works well:

• Query synonym: zeera -> jeera
• Query synonym: zira -> jeera
• Keep product naming as-is in catalog (don’t rename SKUs)

Then add a typo tolerance rule that is strict on short words. For example, allow 1 edit (one wrong, missing, or swapped character) only when the token length is 5+ characters. That helps catch “jeera” vs “jeeraa”, but avoids messy matches on very short tokens.

After the change, autocomplete should guide the shopper instead of guessing too hard. When they type “zee…”, suggest:

• “jeera rice”
• “jeera basmati rice”
• “jeera (cumin)”

And when they submit “zeera rice”, results should show your “jeera rice” products first, plus related items like cumin and basmati, depending on your ranking rules.

One week later, check ecommerce search analytics focused on behavior, not just clicks:

• Zero-results rate for “zeera”, “zira”, and “jeera”
• Search refinement rate (did people retype the query?)
• Add-to-cart rate after search for those queries
• Top clicks to confirm the synonym is not pulling unrelated items

If results get worse (for example, “zira” starts matching a brand name or another category), roll back quickly by disabling only that synonym group, not your whole autocomplete and typo system. Keep a simple versioned config so you can revert in minutes. This kind of tight feedback loop is the core of autocomplete and typo tolerance for Indian ecommerce search.

Quick checklist before you ship changes

Before you push new synonyms, autocomplete, or typo settings, do one quick pass that mixes real query data with hands-on testing. This keeps “helpful” changes from creating noisy results (like matching the wrong product because two words look similar).

Use this short pre-ship checklist for autocomplete and typo tolerance for Indian ecommerce search:

• Pull your top 50 search queries from the last 7 to 14 days, then group them by intent (brand, generic product, variant like size or color, and problem-to-solve like “hair fall oil”). If a query can mean two things, note both.
• Pull your top 50 zero-results queries and decide the fix for each: map to an existing category, add a synonym (local term or spelling), add a missing product, or block it if it is irrelevant. Don’t leave them as “we’ll fix later”.
• Update your synonym and transliteration list with an owner, a last-updated date, and a short reason. This prevents random edits like adding “atta = aata = aataa” in three different places.
• Test autocomplete in your top categories with real users’ phrasing: try English, Hinglish, and common shorthand. Check that suggestions don’t jump to niche items too early, and that they include popular variants (like “1kg”, “500g”, “pack of 2”).
• Stress-test typo tolerance with 20 tricky queries: brand misspellings (especially double letters), mixed numbers (“iPhone 15 pro 256”), and similar-looking product words (“jeera/zeera”, “besan/besan flour”). Confirm the top results are still correct, not just “close”.

If any item fails, ship a smaller change first. A tight rollout beats a big update that makes search feel random.

Next steps: a simple rollout plan (and how to build it faster)

Start with one category where search pain is obvious, like groceries, personal care, or mobile accessories. Keep the scope small for one week so you can see cause and effect. Pick 2 to 3 success metrics you can actually move, such as zero-results rate, search-to-product-click rate, and add-to-cart after search.

A simple rollout that works well for autocomplete and typo tolerance for Indian ecommerce search looks like this:

• Day 1: Baseline: capture current metrics, top queries, and top zero-results queries for the category.
• Days 2 to 3: Ship a small dictionary: add a limited set of synonyms and Hinglish transliterations for the top 50 queries, plus the top 20 brand or pack-size patterns.
• Day 4: Guardrails: add exclusions where meaning changes (for example, “atta” should not match “ata” if “ATA” is a brand or code in your catalog).
• Days 5 to 6: Monitor: track wins (fewer zero results, more clicks) and losses (more irrelevant clicks, higher back-to-search).
• Day 7: Decide: keep, tweak, or revert, then plan the next batch based on what improved.

Make changes reversible. Treat your synonym and typo rules like code: version them, snapshot them, and keep a clear rollback path. If a new rule suddenly makes “face wash” show “dishwash liquid,” you should be able to revert in minutes, not days.

Ownership matters more than clever rules. Assign one person to run a 30-minute weekly review: top new zero-results queries, top “good saves” (typos corrected), and any spikes in low-quality clicks.

If you want to build and iterate faster, Koder.ai can help you implement the search layer with a chat-driven build, use planning mode to map the rules and metrics before you ship, and keep exportable source code so your team can own it long term. It also supports snapshots and rollback, which is ideal when a search tweak needs a quick undo.

Plan your next iteration from measured outcomes. For example, if “zeera rice” started converting but “jeera” now matches unrelated “zera” products, you have a clear next action: tighten that rule, not rewrite everything.