The Hunt
How I scoped, built, and shipped a personal job search tool — and what that process actually looked like.
The problem
My job search ran on a custom HTML tracker I'd built in Cowork. It worked. Until it didn't.
The data lived in local storage — which meant it only existed in Chrome, on one machine, with no guarantee it would still be there tomorrow. I'd added an export button because I knew that was fragile, but "manually export a JSON file so your data doesn't disappear" is not a system. It's a shrug.
The extraction piece was its own problem. Every time I found a job worth tracking, I opened Claude in a separate tab, ran my extraction prompt by hand, waited for the output, then copied the structured fields back into the tracker. Every single time.
Browser-locked. Phone-inaccessible. Backup-by-hand. Copy-paste extraction. Four friction points on a tool I was using every day during an already friction-heavy process.
Something had to go. It can't be the job search, so I fixed the tracking.
How I approached it
Before anyone started building anything, I needed to know what I was getting into.
I came in with a clear problem statement and constraints I wasn't willing to ignore: low cost, within my actual technical capabilities, and I needed to understand upfront what I'd be responsible for versus what Claude Code could handle. I'm technical — comfortable with SQL, familiar with deployment pipelines — but I'm not a web developer. That distinction mattered.
So I asked for options first. Not "build me a thing" — "here are my constraints, what are my options, and what are the gotchas for each." When Supabase came back as the right fit, I asked Claude Code to sketch what the solution would actually look like and to tell me specifically: what it could do, what it could walk me through, and what I'd have to figure out on my own.
Most people skip that and end up three hours in before they find out there's a piece they can't do. I wanted to know before I committed.
The decisions that shaped it
Once I committed to the Supabase solution, four specific decisions shaped how it got built — and each one was a product decision before it was a technical one.
The data is mine. RLS in Supabase locks that down at the database level, not just the application level. Non-negotiable.
I needed a way to secure access without building a full login system. Magic link sends a one-time link to my email — low friction, reasonably secure, integrates with Supabase's RLS so the database knows who's asking before it hands over anything. It took a few rounds of questions before the architecture clicked. I didn't move forward until I understood how the pieces connected. That's not slowness. That's how you avoid building the wrong thing.
The Anthropic API key lives in Netlify's environment configuration, not the repository. This is the difference between a key that's secret and a key that's in your public GitHub repo forever.
Instead of wiring extraction directly into the frontend, it runs as a serverless function — which means the API key never touches the browser, the call happens server-side, and the whole thing is cleaner. Claude Code presented it as an option when I chose Netlify over GitHub Pages. I recognized it as the right one.
The prior version already had a JSON export button, because I'd known local storage was fragile and planned for it. When it came time to migrate, I built an import page, ran the JSON through it, and thirty-eight records landed in Supabase clean. No drama.
Then I kept going
The tracker worked. The job search didn't.
V1 solved the right problem — fragile storage, browser-locked data, copy-paste extraction. All of that was gone. But every morning still meant opening LinkedIn, scrolling, trying to figure out which of the forty-seven things in the feed was actually worth clicking on. The finding was still entirely manual.
So I built a discovery pipeline. But before I did, I made myself answer a question: what does a personal job search pipeline actually need?
Not what's possible. Not what's impressive. What does it need to do?
Agents are having a moment. Every AI workflow these days seems to involve spinning up a fleet of them, and they're genuinely powerful — but powerful and necessary aren't the same thing. I think about this the way I think about real-time data. Everyone says they need it. Almost nobody actually does. The cost of building real-time infrastructure for a problem that a daily refresh would solve just as well is enormous — and the same logic applies to compute-heavy pipelines.
What I needed: new jobs surfaced daily, scored against what I'm looking for, with enough signal to know what's worth clicking. One background function. Three job sources. Claude Haiku for scoring. Free tiers where possible, pennies where not. Nightly. Automatic. Done.
Context is the whole thing
The pipeline scores every job against a profile. That profile is a living document — target roles, hard filters, green flags, red flags, compensation floor, domain preferences, ownership language to look for, coordination-theater language to avoid.
That profile was built with AI. Not because I handed it a resume and said "summarize this" — but because I'd spent months in conversation working through what I actually want, what I've actually done, what kinds of problems make me lean forward versus check out. When it came time to write a scoring brief that an AI could use to evaluate jobs on my behalf, I already had the material. I just had to shape it.
Here's the part that still matters: the pipeline is only as good as what you tell it about yourself. And knowing what to tell it, clearly enough to be useful, is the actual hard problem. A competent developer could build this infrastructure in a weekend. Figuring out what you actually want well enough to brief an AI on your behalf is not a weekend project.
What it does now
Every morning at 5am, the pipeline runs without me. It pulls from two broad job APIs and direct ATS feeds for a curated list of companies I actually want to work for. Each job gets filtered before it ever reaches scoring — remote only, title must match, nothing older than 30 days. That title filter alone eliminated 124 jobs in a single morning run. Product designer, product marketing manager, program manager — gone before they cost a scoring call or thirty seconds of attention.
What's left goes to Claude Haiku with my full profile as the brief. Score, archetype, two-sentence reason, comp flag. By the time I open the app, the doomscrolling is already done.
The tool is new. The thinking isn't.
← Back to library