Private repo · Runs as often as hourly

Finding the roles that want you shouldn’t be the hard part

Role Scout re-checks 1,000+ individual company boards as often as every hour and emails a short morning list of the roles worth applying to, each with a fit score and the reason behind it. Learning the skills and interviewing are hard enough. Finding the roles that actually want you shouldn’t be a third job.

1,000+ Company career boards checked
Hourly Fastest re-check, on GitHub Actions
25 Deterministic screening rules
112 Labeled postings for calibration
1,750+ Tests
<$0.50 Per user per day, projected

Why I built it

A job search is three jobs at once: getting good enough at the work, getting through the interviews, and finding the openings. The first two are worth the effort. The third mostly isn’t. It means refreshing hundreds of career pages, scrolling past senior roles and clearance-only postings, and finding the good one a week after it went up.

So I built the thing I wanted to read each morning: the new roles that fit me, ranked, with a one-line reason for each and nothing I’d have to rule out myself. It’s built for speed to apply, because an early application is the one most likely to get read.

One rule shapes every decision in it: a missed role is worse than an extra one. A false positive costs a line in a digest. A false negative loses a real job, and I’d never know it existed.

What lands in the inbox

Every run ranks roles by how recently they were posted and how well they fit my résumé, then writes a digest: which résumé to send, what the posting actually requires, and why it’s a match. On October 2 it recommended 24 roles out of 4,447 that qualified.

Role Scout · morning digest Oct 2

24 recommended of 4,447 qualifying

Internships & co-ops

Software Engineering Intern — Natera

High fit

US Remote · posted 1h 7m ago by the employer · first seen 6 minutes ago

Résumé: intern-2028, so it reads as a returning student

Why Scripting, schema changes, data validation and unit tests line up with your Python/SQL work, and Google Sheets Apps Script is a stated plus. It is remote within the USA, so no relocation is needed.

Software Engineer Intern — ShopBack

High fit

NYC, SF · posted 11h ago per an aggregator feed, not employer-confirmed

Résumé: intern-2028

Why The posting rewards things built outside class and applied AI work; your arbitrage platform and a live, tested NYCHappyHours site are that kind of evidence. NYC is a listed location.

Two entries from the October 2 digest, restyled for this page and lightly trimmed. The wording is the system’s. Each entry says where its posting time came from, because an aggregator’s timestamp isn’t the employer’s.

Spending money only where it decides something

Reading every posting with a frontier model would work, but running it every hour would cost far too much for anyone but me. So each role passes through a funnel where every tier is cheaper than the next, and a role moves on only when the cheaper tier can’t decide.

  1. Every role on 1,000+ company boards, plus community feeds swept as often as hourly
  2. 25-rule deterministic screen $0 Rules out roles on what they state: seniority, years of experience, clearance, licensure, an advanced degree, the graduation window, location.
  3. A classifier API reads the posting’s facts about $0.05 a run Only for the facts the rules couldn’t settle from the text they had.
  4. Claude scores fit and writes the summary top-ranked roles only Through the API, or through an AI subscription you already pay for.
  5. The morning digest under $0.50 per user per day, projected
The expensive model only reads what the cheaper tiers couldn’t decide. Bar widths are illustrative.

The cheapest win wasn’t clever. I read the classifier’s API docs properly. Asking all of a posting’s questions in one request instead of one per question, then skipping duplicate text and repeated boilerplate, cut the projected cost of re-checking 100,000 postings from $32.09 to $2.81. The boilerplate stripping keeps any sentence that could disqualify a role, so the shortcut can cost a line of noise but never a real job.

Bring your own AI subscription

The last step, the fit review, doesn’t need an API key or a new bill. Plenty of people job hunting already pay for Claude or ChatGPT, so Role Scout can hand that step to the subscription they have. Each run writes a brief with the ranked roles, the rubric, and your résumé. You give it to a Claude or ChatGPT/Codex session, it writes its judgments to a file, and Role Scout imports them.

The import holds the subscription to the same bar as the API. Every row is checked against the same schema and rubric, every role id must match a real posting, and a skipped role or duplicate rank is rejected. Either way, the judgments pass the same checks and land in the same digest.

Through the API

  1. Run sends the top-ranked roles to Claude
  2. Billed per token, on your API key

Through your own subscription

  1. Run writes the brief: roles, rubric, résumé
  2. Your Claude or ChatGPT session judges it
  3. No API key, no extra spend

Same rubric · same schema check · same morning digest

Two ways to run the final review. Both land in the same import, which validates every judgment before it reaches the digest.

Running on a schedule, never silently dropping a role

A fast tier runs every hour, and two full sweeps a day walk every board end to end. A board the run doesn’t reach in time is deferred to the next run, never quietly skipped.

One day of runs, shown in New York daylight time: a fast check five minutes past every hour, and two full sweeps. The sweeps are fixed at 09:55 and 15:55 UTC, so they land an hour earlier on the New York clock in winter.

Every stage that can remove a role has to account for it. Each one returns a receipt, and the run refuses to continue if the numbers don’t add up:

took_in = gave_out + Σ droppedby rule + deferred

Drops are keyed by the rule that made them, never a bare count, so “why wasn’t this role in my digest?” always has an answer that names a rule. A SQLite store caches model results by a hash of the posting’s content, so an unchanged posting isn’t paid for twice. The whole pipeline is covered by 1,750+ tests.

Calibrating the classifier on real postings

Before trusting the classifier, I ran it against 112 labeled postings and kept only the signals that held up. The best one was whether a posting needs a security clearance you already hold. Its scores split into two groups with nothing in between.

The classifier’s clearance scores on the postings the clearance rule flagged, from the 112-posting benchmark. Later, against the production API, it scored an AUC of 1.000.

That gap mattered because the rule was sometimes wrong. It threw out a Leidos junior software engineering role whose posting asked for an active clearance or the ability to obtain one. With the classifier able to overrule the rule, the first production run rescued 27 roles and confirmed 81 as genuine blocks. Graded blind afterwards, 26 of the 27 rescues were right.

Then the full corpus humbled the benchmark. The band it had shown empty wasn’t, and two of the three postings just above the cutoff were wrong rejects: Boeing and Northrop roles that also said “ability to obtain.” I raised the threshold the same day. I also cut three signals that carried no information (one varied by 0.003 across every label). And I dropped the idea of letting the classifier rank fit at all: one posting labeled a reject scored 2.21, above the best exceptional match at 2.03. Fit stays with Claude.

Try Role Scout

This is an early version that isn’t fully rolled out yet. Leave your details below. I run each scan by hand, so expect a short wait: within a few days I’ll email you a free digest of matching roles.

Fields marked with an asterisk are required.

I’m a…
Résumé

Upload a file or paste the text; one of the two is enough.

Up to 3 MB.

For example: new-grad backend, data engineering.

Level

Pick any that apply.

Graduation month and year
Locations

For example: New York, Boston, anywhere in New Jersey.

US work authorization
Security clearance currently held
Industries

0 / 1,000 characters

What I learned

Getting the error direction right mattered more than getting the model right. Once I decided that a missed role is the expensive mistake, most design questions answered themselves: blank locations are kept, unreadable postings go to review instead of the bin, and a cheaper tier may only rule a role out on positive evidence in the posting, never on missing information.

The other lesson was the one the arbitrage project taught me: measure before you trust. The benchmark said a threshold was safe, but the full corpus said otherwise. A signal that looked useful carried nothing. Each time, the honest number was cheaper to hear early.