Autofill can turn a long checkout or registration form into a few clicks. A browser recognises fields for your name, address, phone number, or other information and offers to fill them from details you previously saved. When it works, it feels as if the browser understands the page. When it does not, a phone number may appear in an address field or an old address may be offered at the wrong time.
The useful mental model is simpler: autofill is not reading a form the way a person does. The browser receives clues about what each field is supposed to contain, combines those clues with its own interpretation, and then tries to match the field with suitable saved data. Understanding that process explains both the convenience and the mistakes.
Autofill is a matching problem
Imagine a form with boxes labelled First name, Last name, Street address, City, and Postal code. You can understand those labels immediately because you know what the words mean and how addresses are structured.
A browser needs machine-readable clues. Web forms are built from input controls, and those controls can carry information such as a field name, its type, and an autocomplete value. The autocomplete attribute is part of HTML and can tell a browser that a field is intended for information such as a name, email address, postal code, or telephone number.
That explicit information is useful because the visible wording on a page is not enough by itself. A site might label a field “Mobile”, “Phone”, “Contact number”, or something in another language. A standard field hint gives the browser a more consistent description of the intended data.
Websites do not all provide complete or correct hints, however. Browsers can therefore use additional signals and their own heuristics—rules for making a likely guess—to interpret fields. The exact heuristics vary between browsers and can change over time.
Autofill is consequently best understood as a match between two sides: what the browser thinks the form is asking for, and what relevant information it has available to supply.
Saved information is separate from the web page
When a browser offers your saved address, the website has not necessarily stored that address in the form already. The browser can maintain address or contact information for autofill and offer it when a compatible field appears.
This distinction becomes clearer if you visit a new shopping site. The site can present an empty shipping form, while your browser recognises the fields and offers an address you saved earlier. Selecting that suggestion causes the browser to place appropriate values into the form controls.
The details of storage and synchronisation depend on the browser and its settings. Some browsers can sync autofill information between devices when you use a signed-in profile and enable the relevant synchronisation features. Others may keep particular information locally. The available controls and categories also vary by browser and version.
This is different from a website remembering information in your account. If a retailer stores your delivery address in your account, that address belongs to the site’s own saved data. Browser autofill is a separate convenience layer that can work across many websites.
The browser can fill several related fields at once
Autofill is more useful when it understands a group of fields rather than treating every box independently.
Suppose you have saved this contact information:
- a full name;
- a street address;
- a city and postal code;
- a telephone number;
- an email address.
When you choose that saved profile in a well-structured form, the browser can map each piece to the corresponding field. It is not pasting one large block of text. It is supplying separate values to separate controls.
This is why changing one autofilled field does not necessarily change the others. You might select a saved home address and then manually replace the phone number for that particular order. Once values are placed in the form, they are ordinary form values that you can usually edit before submitting.
Autofill also does not mean the form has been submitted. Filling and submitting are separate actions. A page receives the completed form according to its normal form behaviour when you proceed, just as it would if you typed the values yourself.
Why autofill sometimes chooses the wrong field
Autofill mistakes often begin with ambiguous or misleading form structure.
A developer might give a field an unclear internal name, omit useful autocomplete information, or reuse a form component in a way that does not accurately describe its purpose. A browser then has fewer reliable clues and may have to infer the intended meaning.
Consider a page containing one field for a delivery contact number and another for an order reference. If the page’s markup makes both fields look like generic text inputs with vague labels or names, an autofill system has less information to distinguish them. It may decide that one resembles a phone field even when that guess is wrong.
The opposite problem can occur when a website supplies an incorrect hint. A machine-readable description that says “postal code” is not helpful if the field actually expects something else.
Browser heuristics can also make imperfect guesses. Heuristics are useful precisely because real websites are inconsistent, but a guess that works on thousands of ordinary forms can still fail on an unusual one.
So an autofill error does not necessarily mean your saved information is corrupted. The browser may have correct data but an incorrect interpretation of the destination field.
Similar-looking fields can mean different things
Checkout forms show why context matters. A page may ask for both a shipping address and a billing address. Those groups contain many of the same kinds of fields: name, street, city, postal code, and country.
HTML provides autocomplete tokens that can distinguish sections and purposes, including shipping and billing information. When a form describes these relationships clearly, a browser has better information for choosing and grouping values.
But websites can structure checkout flows in many ways. Some show both addresses together. Some hide the billing form until you say it differs from the shipping address. Some use custom interface components instead of simple visible input boxes. Browser behaviour can therefore differ from one site to another even when your saved information has not changed.
This is a useful reminder that autofill is cooperative. The browser supplies the feature, but the quality of the result also depends on how the web page describes its fields.
Autofill and autocomplete are related but not identical ideas
The terminology can be confusing because “autocomplete” appears both in web standards and in user-facing browser features.
In HTML, the autocomplete attribute gives the browser information about whether and how a field may participate in automatic completion. Its values can describe particular purposes, such as an email address or postal code.
In everyday browser interfaces, people often use autofill to mean inserting stored personal details into a form. A browser may also show completion suggestions based on other kinds of information or previous entries.
The names used in settings menus vary, so it is more useful to focus on the behaviour than on one product’s label. Address filling, payment information, passwords, and general form suggestions may be managed as separate features even if the interface groups some of them under similar names.
Why an old address can keep appearing
If autofill repeatedly offers outdated information, the source may be the browser’s saved profile rather than the website you are visiting.
For example, moving home does not automatically tell every browser profile that your previous address is obsolete. If both addresses remain saved, the browser may continue to offer both. If a synced browser profile is involved, changes may also be reflected on other devices according to that browser’s synchronisation settings.
The practical fix is to review the browser’s saved autofill information and remove or update entries you no longer want. Menu names and locations differ between browsers and versions, so look for settings related to addresses, personal information, autofill, or form filling rather than relying on one exact path.
If the old address appears only on one website, check whether that site also stores addresses in your account. Updating browser autofill will not necessarily change information saved by the website itself, and changing the website account will not necessarily update the browser’s copy.
Review autofilled forms before submitting them
Autofill reduces typing, but it does not remove the need to check important fields.
Pay particular attention when a form affects a delivery, booking, account record, or other transaction where a small mismatch matters. A saved address can be valid but inappropriate for the current order. A browser can also choose an old phone number or misunderstand an unusually structured field.
A quick review is especially useful after selecting an autofill suggestion because several fields may have changed at once. Check the values that matter for the task rather than assuming that a correctly filled name means every other field is correct.
If one field is wrong, you can usually edit it manually without abandoning autofill for the rest of the form. If the same mistake happens repeatedly across sites, reviewing the saved entry can be more useful than correcting the value on every form.
Disabling autofill is a trade-off, not a universal fix
Most browsers provide some control over form-filling features, although the exact options vary. Turning a feature off can prevent unwanted suggestions, but it also removes the convenience of having repeated information entered automatically.
There is no need to disable autofill merely because one website has a poorly recognised form. Manual correction may be enough. On the other hand, someone who rarely fills forms or does not want a particular category of information offered by the browser may reasonably choose to disable or clear that category.
The important point is to treat autofill as an optional assistant rather than an authority. It can save time, but the values still need to make sense for the page in front of you.
The practical mental model
Browser autofill works by matching form fields with information the browser can offer. Websites can provide standard hints that describe what fields mean, while browsers may use additional rules when those hints are missing or incomplete. The browser then inserts matching values into the form, where you can review and edit them before submission.
That model explains the common surprises. A wrong value can result from a misidentified field rather than bad saved data. An old address can come from the browser, the website, or both. And two forms that look similar to you can behave differently because their underlying structure gives the browser different clues.
Autofill is most useful when you let it handle repetitive typing while keeping the final judgement yourself: check the important fields, keep saved information current, and correct the occasional guess that does not match what the form actually asks for.