FormFilla: deterministic form matching for job applications

A compiled Chrome extension with a documentation repository

FormFilla is a browser extension that fills job application forms from a local profile, and it is distributed through the Chrome Web Store. What sits on GitHub is not the program. The README states plainly that the core extraction engine and DOM manipulation logic are closed-source, and that the repository serves as the public documentation, the issue tracker routing point and the release hub for the compiled extension. Badges in the README mark the licence as proprietary, the distribution as closed source and the deployment target as a Chrome extension.

That framing decides how to read everything else in the repository. The directory tree published in the README is described as the internal architecture of the closed-source FormFilla repository, so it is a map of the code, not the code itself. Top-level entries are thin in the expected way, with .github/, LICENSE, PRIVACY.md, README.md, docs/ and store_assets/, and a PRIVACY.md file sitting next to a licence that GitHub cannot classify.

The pitch itself is narrow and worth restating plainly. Candidates spend hours pasting professional profiles into applicant tracking systems, and the extension exists to reclaim that time while keeping the data local.

Scanning the DOM and normalizing the signals it finds

The first stage of the pipeline is element scanning. FormFilla recursively scans the active DOM, including same-origin frame nodes, to locate target inputs. The scanner finds inputs, selects and textareas. From there a repeated block detector identifies school and work cards, which is the hard part of any autofill on an application form, since a candidate usually has several degrees and several jobs listed and each one repeats the same set of labelled fields.

A signal extractor then reads the label, the placeholder, the id and the name attributes of each element. Those four strings are what the matcher has to work with, and they are unreliable in practice: one site labels a field with a visible label, the next with a placeholder, the next with a cryptic id. The normalizer turns them into a common shape through tokenization, case conversion and abbreviation expansion, so that a label reading 'Tel' and one reading 'Telephone Number' can land in the same token space.

The output of this stage is a list of normalized tokens per field. Everything after that is scoring, and the scoring stage never sees the raw page again.

Why the matcher is Hungarian rather than greedy

The README is explicit about the algorithm choice. FormFilla models form filling as a maximum weight bipartite matching problem and solves it with the Kuhn-Munkres algorithm, which is the Hungarian method. The stated reason is that a greedy best-match strategy often leads to field misalignments, which is exactly the failure people notice with autofill tools: two similar labels, one greedy match taken, and the second field left to compete for the key that was just used.

The scoring itself is a signal scorer combining fuzzy similarity and regular expressions, run against the candidate profile JSON. The scores feed a cost matrix built as 100 minus the score, and the Hungarian minimization then finds the assignment that maximizes total confidence across the whole form rather than the best pair for each field in isolation. The result is described as a globally optimal field-to-key mapping.

The distinction matters more than the mathematics does. A greedy matcher can fail on a form with twenty fields because one early mistake cascades; a global assignment can absorb the same noise and still produce a coherent mapping, because every field competes for every key at once.

Writing values into framework-controlled inputs

Filling a field is the part that breaks naive extensions. On sites built with React, Vue or Angular, assigning to the value property gets overridden, because the framework keeps its own state and rewrites the DOM from its virtual tree. FormFilla handles this by retrieving the browser's native property setter descriptors and calling the native prototype setter directly, bypassing the framework's wrapper.

After the value is written, the extension dispatches an input event and a change event, both with bubbling enabled, so the framework's state store syncs with what is now on screen. The element is then highlighted in green or amber for visual review, which doubles as the user's chance to catch a wrong assignment before submitting.

This is also the moment the extension touches files. FormFilla simulates drag-and-drop operations with synthetic DataTransfer streams, so uploading a local resume or cover letter to a file input is done through the same event surface a human drag would use, rather than through a browser API that many sites block.

Sensitivity gating: what never fills without a click

The feature list contains the part of the design that a reviewer will care about most, and it is worth reading closely because the tiers differ.

Standard fields are filled instantly and highlighted in green or amber for a quick visual check. Equal-opportunity fields are disabled unless they are explicitly enabled in the settings panel, so by default the extension will not complete a protected category on your behalf. Critical items, with social security numbers named as the example, are never auto-filled at all. Instead a floating golden badge appears and a manual click is required to confirm injection.

That last tier is a design position rather than a technical limit. It says the tool refuses to fill the most sensitive identifiers automatically even though the machinery to do so is right there, which makes the human responsible for the final confirmation step. Combined with the EEO opt-in, the extension draws its line at two places: fields that carry legal weight and fields that a candidate should think about before confirming.

Local storage, no network requests, and site adapters

Data lives on the machine. The README states that data is stored locally using chrome.storage.local and IndexedDB, that there are no tracking scripts and no server APIs, and that the extension processes everything in memory so contact details, references and resumes never leave the local environment. Zero network requests is the headline claim, and the directory layout is consistent with it: there is no server directory, and the only runtime entry points are a background service worker, a content script tree and the options and popup panels.

The content tree also shows the extension's other strategy, site-specific adapters. Under content/adapters/ the README lists adapter.interface.ts plus generic.ts, greenhouse.ts, lever.ts and workday.ts, and the content/fill/ directory holds separate injectors for comboboxes, dates, files, radio and checkbox groups and selects. So the design is a general matcher with per-site refinements for three widely used applicant tracking platforms, and the private tree confirms the internal split between dom/, matching/, fill/, core/ and ui/.

The matching layer is described in the same private tree, where the scoring and matching algorithms sit next to the DOM code that feeds them:\n\n```text\n │ ├── matching/ # Scoring & matching algorithms\n │ ├── assignment.ts\n │ ├── fuzzy.ts\n │ ├── normalizer.ts\n │ └── scorer.ts\n```\n\nOne caveat follows from the closure: those four files are listed but their contents are not published, so the behaviour described here can only be confirmed against the shipped extension.

Editorial conclusion

FormFilla suits a job seeker who wants a browser extension that keeps personal data on the machine and is willing to install a compiled extension rather than review source. It is the wrong choice for a team that needs to audit the matching logic, vendor it internally, or extend it, because the repository publishes documentation and a directory layout but no engine code. Verify first that the extension you install matches the described behaviour on the sites you actually apply to, that the EEO and sensitive-field gates behave as documented in the settings panel, and that the licence file permits your intended use before loading it into a browser profile that already holds your session.

Frequently asked questions

Official sources

1. AhmadHassan-BTed/FormFilla on GitHub
2. Issues
3. Project website
4. README