Errgo

Inspiration

We came at this from both sides of the same broken system.

Two of us were on the candidate side, getting filtered out before a human ever saw us. Not because we couldn't do the work, but because an ATS scored a resume and decided the answer was no. Good engineers rejected by a keyword matcher.

One of us was on the other side, hiring, and hitting the mirror image of that problem. Candidates who looked great on paper fell apart in interviews, and there was no reliable way to find the people who could actually build. The signal you needed was never in the resume.

So we had both halves of the story. The candidate side watching good people get screened out by the wrong filter, and the hiring side unable to find those same people through the noise. Once we saw it was one problem viewed from two angles, we decided to build the thing that measures what actually matters: how someone works, not how their resume reads.

What we built

Errgo runs candidates through a real assessment, then measures how they got there. We track AI usage and token consumption across the whole session, so we can see the difference between someone who prompts with intent and someone who copy-pastes their way to a broken answer. After the assessment we run a follow-up interview that probes the work they just did, which surfaces whether they understand their own solution or just steered a model toward it.

The output is a graded, human-reviewable picture of a candidate that reflects the way software actually gets written in 2026.

How we built it

The platform is a Vite, React and TypeScript monorepo deployed as static files, with Firebase handling auth, Firestore and Cloud Functions on the backend.

The assessment layer sends candidates a real task and instruments the session, capturing AI interaction and token usage as they work. A grading service scores submissions against structured criteria and hands back section scores and per-criterion results for human review rather than a black-box number.

The interview component is a low-latency voice pipeline. We run FastAPI with WebSockets on GCP Cloud Run, Deepgram for speech to text and text to speech, and an LLM for the conversation itself. Early versions had round-trip latency around 15 seconds, which killed the feel of a live interview. We got that down to roughly 7 seconds through streaming and concurrency work.

Around all of this sits a lead-generation and pipeline layer that segments roles deterministically, synthesizes job descriptions per segment, and feeds the top of the funnel, all automated on a schedule.

Challenges we ran into

Latency was the biggest one. A voice interview that lags feels wrong in a way candidates immediately notice, so cutting the round trip roughly in half took real work on streaming and concurrency control.

Model economics were the second. Running every assessment and interview through a frontier model got expensive fast, so we migrated the analysis path to DeepSeek V3.2 on Vertex AI, added retry logic for flaky calls, and built a sweep endpoint to recover failed analyses instead of silently dropping them.

The subtle one was schema drift. The grader and the frontend evolved on slightly different timelines, and a mismatch between what the grader emitted and what the review UI expected quietly broke grade display. Diagnosing that and building a translation layer to keep the two in sync taught us how much of a real product is just keeping moving parts honest with each other.

What we learned

The technical lessons were the obvious ones. Latency is a product feature, not an implementation detail. Model choice is an economics decision as much as a quality one. Contracts between services rot the moment you stop watching them.

The bigger lesson was about the problem itself. Measuring how someone uses AI turns out to be far more revealing than measuring whether they can avoid it. The signal we actually care about isn't "did they get the answer," it's "do they understand what they built." Everything in Errgo is now pointed at that question.

Built With

• cloud-functions
• deepgram
• fastapi
• firebase
• firestore
• gcp
• github-actions
• hostinger
• llamaindex
• python
• react
• typescript
• vite
• websockets