Building Recruit41's resume screener in 2.5 weeks
From four kinds of stakeholders to a screener that reads 1,000 resumes from one ZIP. How I gathered the requirements, gave every candidate their own Cloud Task, and taught it to read past keywords.

The ask
Recruit41 runs AI interviews. Before this, a recruiter still had to read every resume by hand to decide who to invite. For one role, that can be hundreds of resumes.
The screener had to do that first pass. Read every resume against the job, score each one, and say who is worth an interview. It was also a new product surface. Sales could sell it on its own, and it fed straight into the interviews we already ran.
Requirements came from four places
The ask sounded simple. It wasn't, because each group meant something different by "screener". So before I wrote any code, I spent the first few days talking to each of them.
- Co-founders. They wanted a new thing to sell, and soon. That set the clock. It also meant it had to be safe to ship before it was perfect.
- Product lead. They wanted it to fit the flow recruiters already used. Screening became a stage in the invite wizard, next to interviews and assessments, not a separate tool.
- Sales. They had heard the same question in every demo: "Can I just upload the ZIP I exported from the job board?" Prospects also wanted an export they could forward to hiring managers.
- Customers. They came with whatever they had. A single PDF. A DOCX. An Excel sheet of candidates from an agency. A ZIP of 800 resumes. And they didn't want a bare score. They wanted to know why.
I wrote that down as one short page that everyone agreed to:
- Any input. A single PDF or DOCX, a CSV or Excel sheet, or a ZIP of up to 1,000 resumes.
- One bad file never stops the batch. It shows up as a failed row with a reason and a retry button.
- Every score explains itself. A verdict per rubric, with a quote from the resume.
- No keyword matching. A word in a skills list is not experience.
- Off by default. On for a customer only when they ask for it.
That page did most of the design work. Every later decision traced back to one of those five lines.
One candidate, one task
A ZIP of 1,000 resumes can't be screened inside one web request. It would time out, and one slow resume would hold up the other 999.
So I made each candidate their own unit of work. The upload stores the files in GCS and writes one row per candidate. Then it puts one task per candidate on a Cloud Tasks queue and returns. Each task parses that resume, scores it against the job, and writes the result back to its own row.
This gave us a few things for free:
- Scale. Cloud Tasks controls the rate. A big ZIP just means a longer queue, not a bigger server.
- Isolation. Each task fails on its own. The row records a failure code, such as a parse error or a model timeout, and the recruiter can retry just that row.
- Retries. A failed task retries by itself. Tasks are only queued after the rows are saved, so a worker never picks up a row that doesn't exist yet.
- No stuck rows. A small watchdog looks for rows that have been "running" for too long, for example because a worker died. It marks them failed so they can be retried, instead of spinning forever.
- Live progress. Each row has its own status, so the page fills in as results land.
The failure Claude said couldn't happen
I built a lot of this with Claude. When I asked it whether resume parsing could fail, it said no, quite confidently. Text extraction was a solved problem, it said.
Then we tried real resumes. A DOCX with an image in it broke the document library underneath. It couldn't handle that image, and it threw an error.
That alone would have been fine. The real problem was where parsing ran. Scoring was already in Cloud Tasks, but parsing still ran one resume after another inside the upload request. That was how the existing upload API worked. So one resume with a photo in it failed the whole ZIP. Nobody got screened.
So I moved parsing out of the request too. Parsing became part of each candidate's own job, next to scoring. The upload now only checks the files, stores them and queues the work. If one resume can't be read, that row says so in plain words, and the other 999 carry on.
The lesson I keep coming back to: an AI being sure is not evidence. A test with real, messy files is. I now ask for the failing case before I trust the happy path.
Reading between the lines
The last requirement was the hardest to get right. Most screeners match keywords. If the job says React and the resume says React, it's a match. That rewards people who paste a long skills list.
Ours works from rubrics. The recruiter's job description becomes a short set of rubrics, grouped as must have, nice to have, and impressive. For each rubric, the model gives a verdict (yes, partial, no, or not enough evidence) and one short line quoting where it found it.
Take a rubric like "has worked with React":
- "Skills: React, Node, SQL" and nothing else. That gets partial, flagged as skills list only. It's a claim, not experience.
- "Built the React dashboard our hiring teams use every day" in a past role or project. That gets yes, with that line quoted as the evidence.
- A resume full of real frontend work, but no React anywhere. That gets no. If someone had the skill, they would have mentioned it.
The final score weights the groups, so must haves count most. And the recruiter can always see why. Every cell in the table has its quote, so the screener can be checked, not just trusted.
2.5 weeks, behind a flag
From the first conversation to production on GCP took 2.5 weeks. Roughly:
- The first days. Talking to everyone, and writing the one-page requirements.
- The first build. Screener design, rubric scoring and the candidate table, on a branch.
- The hard part. Uploads of every kind, the per-candidate tasks, failure codes, retries and the watchdog.
- The last days. Exports, the invite wizard, and the parsing fix after real resumes broke it.
It shipped behind a feature flag, set per customer and per job. The code was live in production but switched off for everyone. When a customer wanted it, we turned it on for them. That let sales start selling it straight away, without betting every customer on a 2.5 week old feature.
What I took away
The code was the smaller part. Most of the speed came from the first few days of listening. Five lines that the co-founders, product, sales and customers all agreed on meant I rarely had to stop and ask what to build.
If I had to sum it up: get every group's version of the ask on one page. Make each item its own unit of work, so it fails alone. And test with real files before you believe anyone, human or AI, who says it can't fail.