An open engineering role can sit empty for a month, and most of that month has nothing to do with interviewing. It goes to scheduling calls, chasing replies, running the same screen again, and writing one more rejection email. We gave that whole stretch to AI and used it to hire our own full-stack engineers. We got about 70 recruiter hours back over a two-week pilot, dropped time-to-screen to roughly 17 hours, and kept the same hiring bar we started with. Here's how it works and what it saved.
Most people think "recruiting automation" means faster emails. Faster emails are the easy part. The part that actually saves money is automating the judgment: holding candidate number 100 to the same standard as candidate number 1, without a recruiter losing an afternoon to do it. That's what we set out to build, on our own platform, for our own hiring.
The real cost of manual recruiting
It's not that the hours were invisible. Recruiters felt all of them. They were just scattered across little manual tasks no one bothered to total. So we did:
- 30 minutes running the phone screen.
- 5–15 minutes writing the schedule, follow-up or rejection email by hand.
- 15–30 minutes scoring the call and writing it up.
So, 50 to 75 minutes of recruiter time per candidate before anyone reached a real interview. And none of it ran in parallel. One recruiter could handle about three phone screens a day, and that was the ceiling. Put a healthy top of funnel against that limit and the usual problems show up: candidates waiting days for a slot, calls scored from memory and scattered notes, and rejections that go out late because something more urgent always lands first. The late rejection is the one that quietly costs you the most, because it's the part of your brand candidates actually talk about.
What we built
We didn't build one bot. We built four pieces that run as a single pipeline, because automating a whole process takes more than automating one task.
- Email agent — open the funnel. As soon as a sourced candidate is enrolled, an email agent sends them their phone-screen link. No recruiter involved.
- Voice agent — run the screen. There's no scheduling and no phone tag. The candidate just clicks the link whenever it suits them and runs the screen with our AI voice recruiter, in Vietnamese. The link stays live for seven days, so they can do it whenever they actually have a free moment.
- AI evaluator — score the call. Every finished call is scored against a fixed five-part rubric. This is the piece that makes the speed worth trusting.
- Branch and follow-up. Pass, and an email agent books the technical interview. Fall short, and a respectful rejection goes out on its own, usually within an hour. Follow-up emails wait 48 hours, send at a normal hour between 8am and 9pm local time, stop after two messages, and stop immediately if someone books or opts out.
A recruiter still moves candidates between stages and still makes the final call. Everything in the middle runs on its own.
The ROI: what actually changed
Speed only matters if nothing breaks. Here's the before and after across real candidates:
- Recruiter time per candidate: 50–75 min → 5–15 min.
- Screens one recruiter could run: ~3 a day → no real limit.
- Time-to-screen: days of back-and-forth → ~17 hours.
- Screen completion: patchy, depended on follow-up → 98.5%.
- Rejection turnaround: whenever someone got to it → ~1 hour.
In our two-week pilot (~100 candidates, one full-stack role) that came to roughly 50–90 recruiter hours returned, about 70 on average. Capacity went from a hard ceiling of around 30 screens in that window to 80, with plenty of headroom left.
What matters more than the hours is where they went. The time that used to vanish into scheduling, dialing, note-taking, and writing rejections now goes to the interviews and the actual hiring decision. That's the part that needs a person. The rest didn't.
How we keep the bar high
Every hiring manager asks the same fair question: if you automate screening, don't you lower the bar? Only if you skip the evaluation step.
Every completed call is scored on five metrics, weighted equally, and a candidate has to clear at least four of the five to pass:
- Technical ownership and depth — did they build it, and do they understand it?
- Answer specificity and evidence — concrete examples, or hand-waving?
- Full-stack role fit — real range across the stack we're hiring for.
- Problem-solving and trade-off reasoning — how they think, not just what they know.
- Motivation and logistics fit — genuine interest, and the practical details line up.
Two choices make this work. The rubric scores the candidate, not the AI; the evaluator is told explicitly to judge the person, not the interviewer. And every candidate is scored the same way, so the results are finally comparable instead of reconstructed from messy notes a week later. The score decides the branch: clear the bar and you move to interview booking, miss it and a respectful rejection goes out.
What didn't work (yet)
If this were an ad, we'd stop at the section above. It isn't, so here's the honest part.
Fixed weights cause false rejects. Because all five metrics carry fixed weight, the system can turn down someone who's light on a specific stack or short on years, but is obviously sharp, curious, and quick to learn. A human interviewer would weight those signals differently and move them forward. Sometimes one signal really should count for more. Teaching the scoring to handle that is the main thing we're still working on, so for now a person reviews the analysis (and some of the calls) instead of trusting the score blind.
Getting one agent to handle two languages was hard. A voice agent set up for Vietnamese can't suddenly interview in English, and one tuned for English can't run the call in Vietnamese. But a real engineering conversation here is bilingual by default, the questions are in Vietnamese, the technical vocabulary is in English. So we trained the model to run the interview in Vietnamese while still understanding the English terms engineers actually say: microservices, deployment, latency, pull request, endpoint, CI/CD, and the rest. It tripped over that mix early on and has gotten much better as we've fed it more real interviews. The part that held up from day one: our word error rate sits at 6–7% across accents, which is what makes the transcripts and the scores built on them reliable enough to act on.
Candidate experience
The reaction we didn't expect: candidates liked it. Several told us they were impressed to see AI used this way in a real hiring process — a screen they could take whenever they wanted, with a clear answer either way. For engineers, who judge you partly on how you build things, the screen became a small demo in itself.
Why we ran it on the platform we sell
There's a reason this is written in the first person. We didn't pilot someone else's tool. We built this on Revve, the same platform we put in front of customers. That's a harder test than a demo: if the timing logic or the language handling or the evaluator had been weak, we'd have felt it in our own funnel before any customer did. Hiring our own engineers on it is about as honest a test as we can give it, and it's why the limitations above are in this post instead of buried.
What we'd tell a team starting out
If you're weighing this for your own team, three things saved us the most time:
- Start with the evaluator, not the outreach. Faster emails feel like progress, but the consistency comes from the scoring. Get the rubric right first and everything downstream has something to measure against.
- Keep a human on review. Automation should take the busywork, not the accountability. A recruiter spending 15 minutes reading an analysis is a very different job from a recruiter spending an hour producing one.
- Plan to tune it. Our first version had ten narrow metrics with rubrics that didn't hold up; we cut them to five that do. The model also got noticeably better with mixed-language terms once it had more real calls to learn from. The first month is calibration, not the finished thing.
The benefits, at a glance
- Faster time-to-hire — screening goes from days to hours.
- Higher throughput — the per-recruiter ceiling is gone; candidates book themselves.
- Consistent quality — one fixed rubric, applied to everyone the same way.
- Better candidate experience — instant scheduling, sensible call times, a fast answer in the right language.
- Recruiter time reclaimed — about 80% less human time per candidate, spent on decisions instead.
- Audit-ready hiring — every screen leaves a structured, comparable score.
The bottom line
The interesting part of recruiting automation was never the email or the phone call. It was everything around them: timing that respects a candidate's day, a screen that stays consistent, hand-offs that keep things moving, and a scoring step that holds your bar as the volume goes up. We built it on Revve, and the fact that it now quietly screens our own engineers, limitations and all - is the reason we trust it.
Want to see how it works, or thinking about automating your own hiring? Talk to our team →
