What is an on-demand job fair?

Short answer:an on-demand job fair compresses the traditional "apply, wait, schedule, interview, wait, decide" pipeline into a single live interaction. A recruiter opens a session; seekers join the queue; a 1:1 video interview happens within minutes. No applications, no scheduling, no async limbo.

What problem does this solve?

The traditional hiring pipeline is built for asynchronous communication in an asynchronous market. Both have changed:

The asynchrony tax. A typical first-round interview for a software role takes 2–4 weeks from application to live screen. The seeker is interviewing at five other companies in that window. The role is open to internal politics, scope creep, and reorgs in the same window. Both sides lose signal.
The scheduling tax. Calendar-Tetris between an HM, a recruiter, and a candidate consumes 3–8 calendar days per round. Multiply by 4–6 rounds.
The application-funnel collapse. AI-generated resumes have made high-funnel filtering near-useless. A recruiter who used to triage 200 applications a week is now triaging 2,000, most of them autogenerated.

The on-demand model moves the bottleneck from scheduling to availability, which is a much smaller surface area. Both sides opt in to a live window and meet within it.

How a session works

The full lifecycle, end to end:

A recruiter opens a live event. They attach one or more roles to the event, set a target headcount, and click Go live. The event surfaces in Jobby.dev's discovery feed within 15 seconds.
Seekers discover the event. Either by browsing the feed, by an agent (Claude, ChatGPT, Cursor) calling jobbydev_live_now, or by a direct link in a referral channel.
Seeker joins the queue. One tap. Their profile + role preferences flow into the matchmaker.
Matchmaker pairs. A weighted scoring function (skills, location, salary band, recruiter signal, freshness) runs every few seconds. When a match clears the threshold, both sides get a notification.
Both sides accept. Either side can decline; the slot returns to the queue. Two-sided acceptance kicks off a Daily.co video room.
Live interview. Browser-based, no install. The full interview runs in Jobby.dev — no second tool, no Zoom link, no calendar invite.
Post-interview. Both sides see a structured report card and can mark the candidate as advance, reject, or pass on. Advances drop into the recruiter's pipeline; rejects close out cleanly.

What it isn't

Not an ATS.Jobby.dev does not store a 12-stage pipeline, manage offers, or own the rest of the funnel. Once a match advances, it goes back to the recruiter's system of record (or stays on Jobby.dev as a single-stage pipeline).
Not a scheduling tool. There are no calendar slots on Jobby.dev. The whole product premise is that scheduling is the waste.
Not a job board. Static listings live on traditional boards; Jobby.dev only surfaces roles attached to a currently-live session, so the discovery feed is always actionable.

How it compares to other hiring models

Model	Time to first interview	Coordination overhead	Best for	Worst for
Async pipeline (the default)	2-4 weeks	Calendar-Tetris between HM, recruiter, candidate per round	Senior hires where the candidate pool is small and curated	Volume hiring; candidates with active competing offers
Scheduled job fair (in-person)	Hours, but only on the fair date	Logistics — venue, badges, booth setup	Geographically-clustered talent; campus recruiting	Remote roles; recurring hiring needs
Recruiting agency	1-3 weeks (agency does the screen)	Briefing the agency on what you actually need	Niche or hard-to-fill roles where signal is the bottleneck	Roles with a clear spec and a deep pool
On-demand job fair (Jobby.dev)	Minutes	None per-interview; just "go live"	Active hiring with steady inbound; candidates with competing offers	One-off senior hires; roles needing a take-home

The on-demand model isn't universally better — it's better for a specific shape: high-frequency interviewing against a deep pool, where time-to-first-conversation matters more than per-interview prep depth. For senior IC hires where each candidate is a 20-hour evaluation, the async pipeline is fine — you're not bottlenecked on scheduling, you're bottlenecked on signal.

When the model doesn't fit

Three failure modes worth knowing up front:

Specialist senior roles with thin candidate pools. A staff-level Rust engineer with a specific distributed-systems background isn't showing up in your queue spontaneously. On-demand only works when the inbound rate is meaningfully above zero.
Roles that need a coding screen or take-home. A 20-minute live conversation can't cover what a 90-minute coding screen does. Recruiters running these roles use Jobby.dev as the first screen — quick mutual fit-check before the deeper round — not the only round.
Highly compliance-bound hiring.Government, regulated finance, and some healthcare roles require structured-interview rubrics with multiple raters per candidate. On-demand 1:1 doesn't naturally model that. Possible workaround: panel interviews on Jobby.dev (Power Play tier supports up to 3 recruiters in a room).

If your hiring shape doesn't fit, that's fine — Jobby.dev isn't trying to be a complete ATS replacement. The async pipeline lives downstream of every advance decision.

The economics

For seekers, the platform is free. For recruiters, the math:

Per-hour cost.The Pro tier's 40 hours / month at the listed rate works out to roughly $X / live-event hour. A focused recruiter runs 2 interviews / hour, so per- interview cost is ~$X/2.
Effective ROI vs. scheduling overhead.Industry benchmarks put the burdened cost of a recruiter's hour at $80-150. A typical async first-round consumes ~30 minutes of scheduling Tetris, ~30 minutes of pre-call prep, and ~30 minutes of post-call notes. Jobby.dev compresses that to ~5 minutes before the room (queue review) and ~5 minutes after (report card). The recovered time per interview, ~50 minutes, more than covers the platform cost.
Candidate-side time savings.Seekers spend roughly 2-3 hours per async first-round (search, application, calendar coordination, the call itself, the wait). Jobby.dev compresses this to ~30 minutes for the seeker. At the median tech-job seeker's opportunity cost, that's real value — though seekers don't pay for it, it's why supply shows up.

See billing and plans for the actual numbers and how minutes consumption works at the plan-tier level.

The humans-only rule

Jobby.dev is an agent-native platform — every API endpoint is callable from an MCP-capable agent — but the live interview itself is reserved for humans on both sides. An agent can:

discover live events
join the queue
read the user's queue / match status
manage billing and integrations

An agent cannotaccept a match or sit in the interview room on the user's behalf. That tap is always made by a human, from a browser or native client. This is intentional and is enforced at the scope level on every Personal Access Token. See API scopes for the full list.