Refolk
TeardownApplying at volume

The Job Alert Rebuild Teardown, Six Alerts Scored by Fit Rate and Misses

Score every job alert you run by fit rate and missed fits against employer career-site feeds, then cut to the smallest set that loses no good posting.

21 min readLast reviewed November 20, 2026Read as Markdown

Key takeaways

  • A job alert rebuild needs two numbers per alert, fit rate on unique postings and missed fits against an independent reference set, because tightening a query raises the first while it can silently raise the second.
  • In Refolk's index, US profiles titled Product Owner number 14,456 against 67,167 for Product Manager, so a title:"product manager" alert drops a title family about 21.5% the size of the one it keeps.
  • With zero misses against 10 reference fits, the true miss rate could still be about 30%; it takes about 30 reference fits to bring that upper bound down to about 10%.
  • Indeed documents no more than two dashes per search, and minus terms match body text, so an exclusion like -manager or NOT senior can remove good postings while the inbox looks cleaner.
  • Location or work-setting limits typed into a LinkedIn AI job search prompt are not documented to carry into the alert, which saves your current search criteria, so confirm they appear as structured filters.
  • Daily alerts are the default the timing data supports: in one large study, 41% of applications arrived within 48 hours of posting and 56% within 96 hours.

This guide is for job seekers whose saved searches send dozens of postings a day, most at the wrong level, in the wrong city, or for the wrong job, and who are afraid that tightening them will lose the right ones. It follows one mid-level product manager's six alerts across LinkedIn, Indeed, a niche board, and a search engine, from a word-for-word inventory to a smaller kept set. You come out with a fit rate and a missed-fit count for every alert, checked against postings taken straight from employer career sites, and a dated recheck.

What does a job alert rebuild actually measure?

A rebuild measures two numbers for every alert you run: its fit rate and its missed fits. Fit rate is the share of an alert's unique postings you would actually apply to; missed fits are the postings you would have applied to that the alert never sent.

The two numbers pull against each other. Every minus term or title restriction that cuts noise raises fit rate, and some of them also raise missed fits without telling you. You see the noise in your inbox every morning. The good postings you lost never arrive, so you never see them. That asymmetry is why most people with too many irrelevant jobs in their alerts either never tighten them, or tighten them, feel better, and quietly miss jobs.

Most pages ranking for Boolean search on job boards are operator cheat sheets written for recruiters. They tell you what NOT does. None of them check whether a rewritten query lost a posting you wanted. This guide is that check.

Four terms, used throughout:

  • Fit: a posting you would apply to today, at your level, in a location you would accept, for the job you do.
  • No-fit reason: the single reason a posting fails, coded as level, location, or function.
  • Reference set: a list of fitting postings collected independently of your alerts, here pulled from target employers' own career-site feeds.
  • Missed fit: a posting in the reference set that a given alert never surfaced during the logging window.

You can only count missed fits against a reference set. Without one, a tighter alert will always look like an improvement.

The worked example: six alerts for one mid-level product manager

The example seeker is a mid-level product manager targeting fintech in Chicago, running six alerts across five search surfaces. Here is the inventory exactly as the alerts were saved, which is step one of the method and the step most people skip.

AlertWhereQuery as savedStructured filters
A1LinkedIn keyword"product manager" NOT seniorChicago, mid-senior, daily
A2LinkedIn AI promptmid-level product manager roles at fintech companies in Chicago, hybrid, posted this weekNone set
A3Indeedtitle:"product manager" -senior -directorChicago, IL
A4Indeed("product manager" OR "product owner") fintech -senior -director -internChicago, IL
A5Niche boardproduct managerChicago, remote
A6Search engine"product manager" fintech Chicago jobsDaily alert

A note on numbers. I am not printing this seeker's daily hit counts or fit tallies. They belong to one person's search, and a standard should not carry numbers it cannot source. Every number at a fork below comes from Refolk's index or from published research, and the score sheet in the procedure is where your own counts go. Follow along with your own six alerts, or four, or eleven.

What each board documents about its syntax

The operators differ by board, and some of what matters most is not documented at all.

  • Indeed: the help centre documents title:, quotation marks for exact phrases, OR and AND, company:, and the dash for exclusion. You cannot search a dash term alone, and you should use no more than two dashes per search. The company: operator narrows results to one employer but cannot remove one. Some secondary pages write intitle: instead; use the help-centre form, title:.
  • LinkedIn keyword search: operators must be uppercase, and braces, brackets, angle brackets, and asterisk wildcards are not supported. A secondary source gives the precedence order as quotation marks, parentheses, NOT, AND, OR.
  • LinkedIn AI search: the natural-language job search launched for Premium members in the US. No LinkedIn help page I found says how a prompt treats quotation marks, exact keywords, location, work setting, or recency wording.
  • Niche board and search engine: I have not researched their operators for this guide. Treat whatever you typed there as untested until your log says otherwise.

Two more things are not established publicly: whether Indeed keeps operators when a search becomes an alert, and whether LinkedIn keeps the Boolean logic in the keyword string it saves. LinkedIn does say an alert is created for your current search criteria. The only way to know is to compare an alert's hits with the same search run live.

Where an alert's limits actually live

  1. Prompt wording
    Location, hybrid, or recency typed into an AI prompt; no documented promise it persists
  2. Keyword string
    Quotes, OR, NOT, dashes; saved with the alert, Boolean survival untested
  3. Structured filters
    Location, experience level, work setting; visible on the saved alert
  4. Delivery settings
    Daily or weekly, email, app, or both
The further a limit sits from the structured filters, the less evidence there is that the alert enforces it.

Four forks are visible before any logging starts. A1's NOT senior matches body text. A2's location lives only in the prompt. A3 is title-only. A4 carries three dashes, one more than Indeed documents. Each one gets tested below instead of assumed.

Why the reference set comes from employer career sites

The reference set has to come from a source your alerts do not use, and employer career-site feeds are the cleanest one available: they are the primary record of a posting, with a stable job ID and a first-published date. Job boards cannot serve as the reference, because they are what you are testing and because they repost and duplicate heavily.

How heavily is disputed. One job-data company's pipeline reported these collapse rates, meaning the share of postings that turned out to be duplicates once matched across sources:

SourcePostingsUniqueCollapse
Indeed256.6M128.7M49.9%
LinkedIn198.4M78.3M60.5%
MyWorkdayJobs15.4M11.1M27.8%
iCIMS2.4M2.4M2.6%

The same company's data-quality page gives LinkedIn under 10% and Indeed under 15%. A practitioner puts cross-source duplicates at around 1 to 3%. Academic work on duplicate detection cites an industry estimate that an average job ad is re-posted two to five times. These sources disagree by an order of magnitude, so do not use any of them to predict your own duplicate rate. What they agree on is direction: aggregators duplicate far more than an employer's own system does.

Which feeds to pull

An applicant tracking system (ATS) is the software an employer uses to publish jobs and receive applications. Three common ones expose public feeds that need no key:

  • Greenhouse: one call returns the employer's whole board, with no paging. Each job carries id, title, location.name, first_published, updated_at, and absolute_url. Descriptions are not included by default; without content=true you get titles and links only.
  • Lever: one postings feed per employer slug, in JSON.
  • Ashby: one job-board feed per employer slug.
Reference-set feed calls, one per target employer
Greenhouse:              https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs
Greenhouse with text:    https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs?content=true
Lever:                   https://api.lever.co/v0/postings/{slug}?mode=json
Ashby:                   https://api.ashbyhq.com/posting-api/job-board/{slug}

Per posting, record:  id | title | location.name | first_published | absolute_url | date I first saw it | fit (Y/N)
Per employer, record: ATS name | token or slug | feed works (Y/N) | manual careers-page check needed (Y/N)

Replace the token or slug with each employer's own; add content=true on Greenhouse only when you need descriptions for the pre-test.

How big the reference set needs to be

No published minimum exists for a meaningful missed-fit rate. A standard statistics rule, which I have not seen published for job search specifically, gives a usable floor: with n reference fits and zero misses, the 95% upper bound on the true miss rate is about 3 divided by n.

  • 10 reference fits, 0 misses: the true miss rate could still be about 30%.
  • 15 reference fits, 0 misses: about 20%.
  • 30 reference fits, 0 misses: about 10%.

That is why the method asks for 15 to 30 target employers. If two weeks produce fewer than 10 reference fits, add employers before you trust a zero.

What a title-only search loses in the product title family

A title-only search such as title:"product manager" drops every adjacent title in the family, and in product management the biggest adjacent title, Product Owner, is about a fifth the size of Product Manager in the US. Keyword searches keep those variants but also pull in postings and people that merely mention the words.

Here is the title family as it appears in Refolk's index of professional profiles, with the share of a 25-profile sample whose current title was exactly the searched title:

TitleCountryProfilesExact-title share
Product ManagerUnited States67,16788%
Product ManagerUnited Kingdom15,70576%
Product OwnerUnited States14,45664%
21.5%
Size of the US Product Owner title family relative to Product Manager
In Refolk's index, 14,456 US profiles hold the title Product Owner against 67,167 for Product Manager, and a title:"product manager" alert reaches none of them.

Two readings from those samples bear on the A3 versus A4 fork:

  • Variants are common, and more so in the UK. In the UK Product Manager sample, 6 of 25 profiles did not hold the exact title, with variants including Lead Product Manager and Head of Digital Product. In the US sample it was 3 of 25. With samples this small, treat it as directional: a title-only alert probably loses more in the UK.
  • The keyword is noisy. In the US Product Owner sample, 7 of 25 current titles were not product roles at all: CEO, CTO, co-founder, VP Marketing, consultant. Matching on "product owner" anywhere in the text pulls in that kind of noise.

These are profile titles, not posting titles, so they show the shape of the family rather than forecast your alerts. Your reference set gives the real answer. List every reference-fit title that title:"product manager" does not match. If any reference fit is titled Product Owner, A3 loses it, and A4's OR is earning its place. In the example, the decision rule was simple: keep a title variant in the query if any reference fit carries it, and remove noise with structured filters for level and location, not with body-text minus terms.

The rebuild procedure, step by step

The procedure is eight steps over about two weeks: inventory, reference set, log, dedupe, code, score, pre-test, cut. The time estimates are mine and come from running it, not from a published source. LinkedIn caps members at 20 alerts at once, so the inventory has a ceiling.

Rebuild and prove a job alert set

  1. Inventory every alert word for word
    Copy each saved search and alert exactly as stored: board, query or prompt text, location, level and work-setting filters, frequency, and channel. Done means one row per alert, with nothing paraphrased.
  2. Build a reference set from employer feeds
    Pick 15 to 30 target employers, find each one's ATS board token, and pull their public feeds daily, noting first_published. Done means a running list of fitting postings with ATS job IDs, plus a note of which employers have no feed.
  3. Log every alert hit for 14 days
    Record each hit with board, URL, employer, title, city, and date, about 10 minutes a day. Done means a raw hit table covering two full weeks for every alert.
  4. Deduplicate before you count anything
    Match on ATS job ID or URL first, and only then on employer plus title plus city, never employer plus title alone. Done means a table of unique postings, each tagged with every alert that surfaced it.
  5. Code each unique posting fit or no-fit
    Mark each unique posting fit or no-fit, and give every no-fit one reason: level, location, or function. Done means a coded table with no blank reasons.
  6. Score fit rate and missed fits per alert
    For each alert, fit rate is fits divided by unique hits, and missed fits are reference fits the alert never surfaced. Done means one score row per alert, including the fits only that alert caught.
  7. Pre-test every rewrite against the reference set
    Before saving any new minus term or title restriction, run it against every reference fit's title and description. Done means the rewrite loses no reference fit, or you have written down which one it loses and why you accept that.
  8. Cut to the covering set and date the recheck
    Keep the fewest alerts that together cover all reference fits, delete the rest, and put a recheck date in your calendar. Done means a kept list and a dated calendar entry.

The dedupe order

The dedupe key decides whether your fit rate means anything. Match on the most specific field first and fall back only when it is missing.

Dedupe key order for alert hits

  1. ATS job ID
    Same ID seen on two boards is one posting
  2. Apply URL
    Same employer URL is one posting
  3. Employer + title + city
    Fallback only, and city is mandatory
  4. Tag sources
    Each unique posting lists every alert that surfaced it
Match on the strongest identifier first, and never merge on employer and title without the city.

Coding fit honestly

Coding is where the method gets subjective. Decide fit by the posting, not by how the alert was phrased, and code the reason for every no-fit, because the reasons tell you which rewrite to try: a pile of level no-fits calls for a level filter, a pile of location no-fits calls for a structured location field. If you want the call to be consistent across a few hundred postings, Refolk scores how well you fit each posting against your own work history, which turns fit or no-fit from a mood into a repeatable reading.

Alert inventory, hit log, and score sheet
INVENTORY (one row per alert)
alert_id | board | query_or_prompt_word_for_word | location_filter | level_filter | work_setting_filter | other_filters | frequency | channel | date_saved

HIT LOG (one row per hit, 14 days)
date | alert_id | board | url | ats_job_id | employer | title | city

UNIQUE POSTINGS (after dedupe)
posting_key | employer | title | city | alerts_that_surfaced_it | in_reference_set (Y/N) | fit (Y/N) | no_fit_reason (level / location / function)

SCORE (one row per alert)
alert_id | unique_hits | fits | fit_rate = fits / unique_hits | reference_fits_surfaced | missed_fits = reference_fits - surfaced | fits_only_this_alert_caught

Keep each block as its own sheet tab; one row per alert, per hit, per unique posting, and per alert score.

How this goes wrong: the wrong turns and false positives

The common failures in an alert rebuild all have the same signature: the fit rate improves while missed fits rise or become invisible. Each one below names what it looks like when it lies and the local check that catches it.

A minus term that matches body text

A1's NOT senior and A3's -senior are meant to remove senior-level postings. A minus term is not limited to the title, so it also drops any posting that mentions the word anywhere, such as one describing work with senior stakeholders. The documented version: excluding "Manager" from a search for engineers also removes "Engineering Manager". When it lies: noise falls, fit rate looks better, and missed fits rise. Check: the pre-test in step 7, run against descriptions pulled with content=true. Indeed also suggests phrase-based exclusions such as adding "no security clearance" to a search, which target a phrase rather than a single word and may be safer; test them the same way. No published, measured test of minus-term loss on job alerts exists, so your reference set is the only evidence you will get.

A third dash on Indeed

A4 carries -senior, -director, and -intern. Indeed documents no more than two dashes per search, and what happens to the third is not verified. When it lies: the alert runs without error, so you assume all three exclusions apply. Check: run the search with two dashes and with three, compare hit counts, and drop the dash that matters least, or replace it with a level filter.

Limits that live only in a prompt

A2's Chicago and hybrid exist only in the prompt text. A LinkedIn help passage quoted by a third party says to refine with filters and then turn on the alerts toggle once all filters are applied, which implies filters are what persist. That is unverified against a primary LinkedIn page. When it lies: the first live results look right, so you trust the alert, and later digests drift to other cities. Check: open the saved alert and read its fields, not its name.

Title-only searches that miss variants

A3's title:"product manager" cannot return Product Owner postings, a family 21.5% the size of Product Manager in the US by Refolk's index. When it lies: fit rate is high because every hit has the right title, while every variant-titled fit is missing. Check: list reference-set titles that the title: string does not match.

A dedupe key that is too coarse

Merging on employer plus title, without city, collapses different jobs. One documented dedupe on that key merged 353 rows, of which 347 were distinct jobs, and 188 of the merged groups, 97%, contained more than one location. When it lies: fewer unique postings, a tidier table, and missed fits hidden inside merged rows. Check: count distinct cities inside each merged group.

Duplicates that inflate the fit rate

The same fitting job seen on three boards counts three times if you score raw hits. When it lies: a broad aggregator alert looks like your best performer. Check: compute fit rate on unique postings only.

A reference set that only covers some employers

A set built from Greenhouse, Lever, and Ashby feeds leaves out employers on Workday, iCIMS, and other systems, so missed fits there are invisible. When it lies: zero missed fits, because the misses happened where you were not looking. Check: record each target employer's ATS, and check the employers without a feed by hand on their careers pages.

A reference set too small to prove anything

Zero misses against 10 reference fits still allows a true miss rate of about 30%. When it lies: a clean zero that you treat as proof. Check: apply the 3 divided by n rule before you delete anything.

Every wrong turn here has the same signature: the inbox gets quieter and the misses get harder to see.

Which alerts to keep, rewrite, or cut

Keep the smallest set of alerts that together surfaces every reference fit, and judge each alert on two things: its fit rate and whether it catches fits no other alert catches. A noisy alert that is the only one catching some fits stays until a pre-tested rewrite covers them.

Keep, rewrite, or cut each alert

Catches fits nothing else doesCatches no unique fits
Rewrite
Move limits into structured filters, pre-test, keep until the rewrite covers its unique fits
Keep
Leave as is and protect it from casual edits
Cut
Delete it; it adds noise and no coverage
Redundant
Cut it, or keep it only if it reaches you sooner than the alert that duplicates it
Low fit rateHigh fit rate
An alert's value is the fits only it catches; fit rate decides whether it is worth reading or worth rewriting.

To find the covering set, work greedily from the score sheet:

  1. Start with the alert that surfaced the most reference fits.
  2. Add the alert that surfaces the most reference fits not yet covered.
  3. Repeat until every reference fit is covered, or no remaining alert adds one.
  4. For each reference fit no alert caught, either write a new pre-tested alert for it or record the gap as accepted.
  5. Delete everything not in the set.

So how many job alerts should you have? As many as the covering set needs. LinkedIn's limit of 20 is a ceiling, not a target. One ranking guide recommends three precise alerts; that may be right for many searches, but nothing in it was measured, and your covering set is. If a saved job search is not showing relevant jobs, the score sheet usually says why: the no-fit reasons cluster on level or location, which points at a missing structured filter rather than a missing keyword.

Once the kept set is sending mostly fits, the bottleneck moves from finding postings to answering them. That is the point where Refolk earns its place: it tailors your resume to each posting you apply to and drafts the cover letter, so a clean alert set turns into applications on the same day instead of a backlog.

How often the kept set should fire, and when to recheck it

Set every kept alert to daily, because most applications arrive in the first few days a posting is live, and recheck the set on a fixed date rather than when it feels noisy. LinkedIn alerts default to daily and can go out by email, app notification, or both.

WindowShare of applicationsSource
First 24h (7-day listings)25%UK job-board report
First 48h41%Davis and Samaniego de la Parra
First 96h56%Davis and Samaniego de la Parra
Mean posting life9.8 daysDavis and Samaniego de la Parra

The rows come from two studies with different samples, so read each against its own source and do not chain them into one curve. The US figures come from about 80 million applications to about 10 million postings. A weekly digest can reach you after more than half the applicants have applied to a posting whose average life is under ten days.

Pick the recheck date when you cut the set, and put it in your calendar. I would set it about a month out, which matches one ranking guide's advice to purge broad alerts monthly, though that advice is not tested either. Recheck early if you change your target level, your city, or your title family, because each change invalidates part of the reference set.

Before you call the rebuild done

  • Every alert I run is written out word for word, including AI prompt text and every filter.
  • The reference set holds at least 10 fits, and I know the 3 divided by n bound for my count.
  • Each target employer has its ATS recorded, and employers without a feed get a manual check.
  • Fit rates are computed on unique postings, deduplicated by job ID or URL before employer, title, and city.
  • Every no-fit has one coded reason: level, location, or function.
  • Every minus term and title restriction in the kept set passed the pre-test against reference fits.
  • No Indeed alert in the kept set uses more than two dashes.
  • Location and work setting on every LinkedIn alert show as structured filters on the saved alert.
  • Every kept alert is set to daily delivery.
  • The kept set covers every reference fit, or each uncovered fit is recorded as an accepted gap.
  • A recheck date is in my calendar.

Questions job seekers ask

How many job alerts should I have?

Keep as many alerts as it takes to cover your reference fits, and no more. LinkedIn caps members at 20 alerts at once, which is a ceiling, not a target. One ranking guide recommends three precise alerts, but that number is not measured against anything. Score each alert's fit rate and missed fits for two weeks, then keep the smallest set that together surfaces every reference fit. For one seeker that might be two alerts; for a broad search it might be six.

Why does my saved job search keep showing irrelevant jobs?

Usually the limit you care about lives somewhere the alert does not store or does not enforce. Common causes are a location or remote preference typed into an AI prompt instead of the structured filter, a keyword matching body text rather than the title, and level never being set as a filter. Open the saved alert, read what it actually stores, and move every limit you can into structured fields. Then code two weeks of hits by no-fit reason to see which cause dominates.

Does LinkedIn's AI job search keep the location from my prompt when I turn on an alert?

That is not established publicly. LinkedIn says an alert is created for your current search criteria, and a help passage quoted by a third party says to refine with filters before turning on the alerts toggle, which implies structured filters are what persist. No LinkedIn page I found says how a prompt's location, work setting, or recency wording is handled. Check locally: open the saved alert and confirm location and work setting show as filters.

Can I use minus terms or NOT in Indeed job alerts?

Indeed's help centre documents the dash for exclusion, with two limits: you cannot search a dash term alone, and you should use no more than two dashes per search. Indeed's career guide lists NOT, but the help centre documents only the dash. Whether operators survive when a search is saved as an alert is not established publicly, so compare the alert's hits with the same search run live for a few days.

Should job alerts be daily or weekly?

Daily. In a study of about 80 million applications, 41% arrived within 48 hours of posting and 56% within 96 hours, and single-position postings lasted 9.8 days on average. A weekly digest can reach you after more than half the applicants have already applied. LinkedIn alerts default to daily, so check that none of your saved alerts were switched to weekly.

How long should I log alert hits before cutting any alerts?

Log for 14 days, and do not trust a zero missed-fit count until your reference set holds enough fits. By a standard statistics rule, zero misses against 10 reference fits still allows a true miss rate of about 30%, and 30 fits brings that to about 10%. If two weeks yield fewer than 10 reference fits, add target employers and keep logging rather than cutting.

Put this to work

Paste your career in once. Every application after that is written for you.

Drop a resume or a LinkedIn URL. I rank the live openings against it, rewrite the resume and write a cover letter for the best of them, and fill in the employer's form when you press the button. You read, you decide what goes out.

  1. 01Drop your resume

    A PDF or a LinkedIn URL. About a minute, once.

  2. 02I rank the openings

    Every weekday morning, the live catalog scored against your history. Up to 20 worth your time, not two hundred links.

  3. 03Each one is written up

    Resume rewritten for the posting, a cover letter, a fit score. Press send, or let me fill in the form.

  • New matches ranked and written before you are up.
  • Every bullet stays inside what your history supports. Nothing invented.
  • Queued, submitted, interviewing, offer: one screen, not a spreadsheet.

Free, no card. Up to 25 applications sent a week, and nothing is sent until you say so.

Read next