In-app search doesn't forgive typos: how this breaks the funnel
A user types "nike air max 90 sneakers," misses by one key — "nike air maz 90" — and gets a "Nothing found" screen. They won't correct the query: they close search, browse categories, or leave for another app.
A single typo in a search query severs the path to an order at the most valuable stage of the funnel, where the user already knows what they want to buy.
The cost of this failure shows up in the metrics: the share of empty results grows on long queries with brands and SKUs, and in-app search conversion drops severalfold compared to error-free queries.
Yet search formally works — the index responds, the interface doesn't crash, and there isn't a single error in the logs. The problem isn't infrastructure failure, but that the search layer can't match user input against the actual catalog.
AI typo correction in search closes this gap: the model recognizes the distorted word on the fly, picks the most probable product query, and returns relevant results instead of an empty screen.
Mobile app search quality stops depending on how carefully users type on a small keyboard — and that's exactly where most users make mistakes.
Next, we break down how this works: which types of errors we catch, where the line runs between correction and substituting the query, and how we measure the effect on the funnel.
How AI typo correction works in search and what changes
Correction modes: from substitution to a language model
The basic level is dictionary correction by edit distance: the query is checked against an index of popular formulations, and if it differs by 1-2 characters, the closest variant is substituted.
This is cheap and predictable, but it breaks down on concatenated and transliterated queries. Phonetic matching covers this class: "айфон" and "iphone" are reduced to a common sound code and find each other, even if written in different alphabets.
Fuzzy search works not instead of, but on top: it does not rewrite the query, but expands the results — tokens with typos still participate in ranking, and the user sees results without an empty screen.
A language model for search is connected at the last layer and solves what rules cannot describe: it restores meaning from the context of the phrase, distinguishes "кофе" and "кофта" with similar spelling, and suggests a continuation.
| Variant | When it fits | Limitations |
|---|---|---|
| Dictionary correction | A catalog with stable names, a stable query dictionary | Does not handle concatenated and transliterated inputs |
| Phonetic matching | A multilingual audience, brands and names | False positives on short words |
| Fuzzy search | The long tail of queries, a wide assortment | The load on the search index grows |
| Language model | Conversational and compound queries | Requires labeling and regular re-evaluation |
We take search quality metrics before and after: the share of queries with zero results, the share of clicks into the card from the top five results, the share of repeated query refinements.
From them it is clear whether a class of failures is gone or the correction simply rearranged the results. We enable the layers one at a time and compare on the same slice of queries — otherwise the effect cannot be separated from seasonality.
Elasticsearch
Stages of implementing typo correction in app search
Implementing AI typo correction starts not with a model, but with data: without real user queries, any scheme remains a guess. Therefore, the first step is to export search logs for a period sufficient to cover seasonal spikes and see what share of queries ends with zero results.
This is usually where typos, transliteration, and concatenated words hide — the user gets nothing and leaves the app.
After that, the work proceeds in stages, each ending with a verifiable artifact.
- Search query audit. We analyze the logs: high-frequency queries, the share of empty results, typical distortions — missing and transposed characters, extra ones, keyboard layout in the wrong language scheme. The output is a slice of problematic queries with an estimate of how much traffic they affect.
- Designing the typo correction scheme. We determine where to apply the correction: at the search input, at the index level, or as a "did you mean" suggestion. We choose the trigger threshold so as not to substitute rare but correct queries — otherwise search will start "correcting" product and brand names.
- Setting up fuzzy search. We enable edit distance and phonetic comparison, configure an exception dictionary for catalog names. We test on historical queries: how many typos are resolved automatically, how many go to suggestions.
- Search quality validation. We calculate the share of queries with non-empty relevant results before and after, and look at the position of the desired result. Separately, we check that correct queries have not started being rewritten — this is the main risk with aggressive thresholds.
- Handing over the solution to the client. We deliver the configured scheme, dictionaries, threshold configuration, and quality metrics so the team can maintain search without us.
The key moment is the validation stage: without it, typo correction easily turns into a source of new errors. We run both slices on the same set of queries so that the effect is measurable rather than perceived. Describe your task — we will come back with an estimate and a plan based on these stages.
How does fuzzy search differ from typo correction?
Fuzzy search and typo correction solve different problems, although from the user's perspective they look the same — "it found what I meant." Fuzzy search expands the match area: the query is compared against the index by edit distance, phonetic keys, or vector proximity, and similar strings end up in the results.
Typo correction works differently — it first brings the query to its presumed correct form, and only then searches by it. The difference between the approaches shows up at the moment when the query contains no error, but there is also no exact match in the catalog.
Fuzzy search increases recall: it pulls out products and articles that the user otherwise would not have seen. The price for this is a drop in precision.
With a loose threshold, positions far off in meaning creep into the results, and the person scrolls through the list without trusting the result. With a strict threshold, some real typos are not caught, and recall returns to the level of ordinary search.
Typo correction works on precision: the query "wireless headphones" after normalization turns into "wireless headphones," and the search runs on the clean wording. Here the risk is different — a false trigger.
If the algorithm "corrects" a brand name, a SKU, or a rare term, the user gets results for a query they did not make, and loses trust in search more strongly than from an empty page.
In practice, the approaches are combined in a pipeline. First the query goes through normalization and typo correction using a dictionary and frequency pairs — this removes the noise.
Then, on the cleaned query, fuzzy search is launched with a controlled threshold in order to pick up close positions. The threshold is tuned by metrics: the share of queries with no results, the share of clicks from the results, the share of query refinements. Only from these numbers can you see where useful recall ends and garbage begins.
For a mobile app this is critical: the screen is narrow, the user does not scroll through long lists and leaves after the first failed result.
That is why typo correction is kept conservative — it must not change queries that already produce a result — while fuzzy search is enabled as a second layer with a limit on the number of candidates.
Case study: how typo correction increased search conversion
The client is a service with a catalog of tens of thousands of items and a search that handles the bulk of orders. Analytics showed that a noticeable share of queries ended in empty results or users leaving to the second or third page.
The cause turned out to be not relevance, but typos and keyboard layout — the user types "iphone chekhol", the system looks for an exact match and returns zero. Each such query is a lost order that no one sees in reports, because formally the search "worked".
What it was like before implementation
We took a snapshot of logs over several weeks: the share of successful queries held at around 71%, empty results — about 18% of all search requests, and some users got results but did not find what they needed and left. Search-to-order conversion was 4.2%.
Separately, we calculated the share of queries with signs of typos or mixed keyboard layout: it turned out to be higher than the team had assumed, and it grew on mobile, where the keyboard misses more often.
What was changed
We introduced an AI typo correction layer in front of the search engine: the model brings the query to its dictionary form, takes into account keyboard layout and phonetic similarity, and only makes a correction decision when confidence is sufficient — otherwise the query goes through as is, so as not to substitute rare but valid names.
The corrected variant does not replace the original: the user sees "Did you mean…" and can return to their own variant.
In parallel, we added logging of "query → correction → result" pairs to see where the model makes mistakes. This provided a manageable loop: disputed cases go into review, the dictionary is expanded, and quality grows without retraining from scratch.
What it became
| Metric | Before | After |
|---|---|---|
| Share of successful queries | ~71% | ~89% |
| Empty results | ~18% | ~6% |
| Search-to-order conversion | 4.2% | 5.6% |
| Share of queries with correction | — | ~14% |
The growth in search conversion gave an increase in orders without changes to the catalog or prices — the effect came from existing traffic. Empty results stopped being a "silent" loss zone: they are visible in monitoring and can be reviewed in a targeted way.
Elasticsearch was used as the search engine, and the correction layer was placed in front of it — this way the solution does not depend on the internal logic of the search and can be transferred to another stack.
Compatibility, migration, and access concerns — let's discuss the task
The customer's main concern sounds like this: "we already have search running, and it works for us — will AI typo correction break it?" Let's answer directly: the typo correction layer is placed in front of the current search engine and does not replace it.
The query goes through normalization, the corrected version is sent to the existing index, and if the model's confidence is below the threshold, search runs on the original string, as before.
Compatibility with the current search is preserved at the level of the query contract, so there is no need to rewrite the ranking logic.
What if the index has to be rebuilt? Migration of the search index happens in parallel: the new index is built alongside the old one, and traffic is switched over after comparing results on a control sample of queries.
Rolling back changes means switching back to the previous index, not restoring from a backup, so it takes minutes. We grant data access on the principle of least privilege: the correction service sees only search strings, with no linkage to accounts or order history.
Can typo correction be implemented without stopping search?
Yes. The layer operates in observation mode: first it only logs which queries it would have corrected, and we compare this against actual results. Switching to live mode is a separate step with instant rollback. The user does not experience a single moment of downtime.
After implementation, the customer receives:
- configurations of the correction layer with confidence thresholds and bypass rules;
- a diagram of the query path from input to results with logging points;
- an access policy for search data and role separation;
- a regulation for index migration and a rollback procedure with trigger criteria;
- search documentation: dictionaries, normalization rules, quality metrics;
- a dashboard with the share of corrected queries and the growth in successful transitions.
Describe your current search setup and access constraints — we'll come back with an assessment and an implementation plan.
Timeline for implementing typo correction by stage
Implementing AI typo correction in search breaks down into stages with predictable durations — from auditing search queries to rolling out to the entire audience.
The approximate timelines below are given for a typical application with an established search output; the final implementation plan is influenced by the volume of query logs, the number of interface languages, and data privacy requirements.
The duration of tuning depends not so much on the model as on the quality of labeling: if the logs contain many short queries in mixed languages, the data preparation stage stretches out.
We build the implementation plan so that each stage produces a verifiable result — after the audit it's clear what share of misses the correction closes, and after integration — how the share of successful searches changes.
The stages partially overlap: data preparation can begin before the audit is complete, and testing can run in parallel with retraining. That's why the total implementation time is usually shorter than the sum of the stages.
Describe your search output and the volume of logs — we'll come back with an estimate and a plan for your case.