Skip to main content
Malpractice detection

Know whether the score you are reading is the candidate's.

Expert Hire watches live rounds for known AI-assistant overlay tools, signs of impersonation and tab switching, then analyzes the video after the round. Every signal lands in front of a human reviewer, next to the transcript and the code. A flag is never an automatic verdict.

Book A Demo

30-day free trial, nothing charged for 30 days. Proctoring adds nothing to any assessment, and the desktop proctoring app unlocks on Growth and Scale.

  • Known AI-assistant overlays
  • Tab switches, counted live
  • Reviewed by a person, always
An Expert Hire interview report with integrity signals available for review
Signals are evidence for review, never an automatic verdict.
The integrity gap

Every candidate now has an assistant open in the next window.

A candidate sitting alone at a desk has a general purpose model one keystroke away. A whole category of software now exists to put that model on top of an interview without the interviewer seeing it.

So a 90 on a remote coding round no longer tells you much on its own. It might be an excellent engineer. It might be an excellent assistant. Until you can tell the two apart, every decision after it is a guess.

The remote round quietly became an open-book exam.

An overlay tool sits on top of the interview window and feeds answers back. You score the tool and call it a candidate.

The take-home stopped separating anyone.

When every submission is clean and fast, the exercise no longer ranks people. It just costs your team a review cycle each.

The person on the call may not be the person on the offer.

Impersonation used to need effort. On a remote round it needs a second laptop and a friend who is free that afternoon.

You find out in week three, not in round one.

A bad screen shows up in the first sprint, long after the pipeline moved on.

What is actually detected

Four signals, and we are specific about each one.

Here is what Expert Hire looks for, what each signal means, and where it stops. All of it is evidence for a person to weigh. None of it is a decision.

Known AI-assistant overlay tools.

Software built to float an assistant over an interview window, often designed to stay out of a screen share. Expert Hire detects known tools of this kind while the round is running.

Detection of known tools, not a promise that no tool will ever be new.

Signs of impersonation.

Signs that the person answering may not be the person who registered for the round. A reviewer checks them against the recording. The software does not settle it.

A signal to verify, never an accusation the software makes on its own.

Tab switching during live rounds.

Every switch away from the assessment is counted while the candidate works, and the running count sits in the assessment header where both the candidate and the reviewer can see it.

A count of an event. Why it happened is a question for a person.

Post-interview video analysis.

After the round ends the recording is analyzed. The result goes onto the candidate report, so integrity status sits with the score, the recording and the transcript.

Analysis of what the session recorded, not a personality or emotion read.

What we do not claim.

This is not a lie detector, and scoring never runs off a face scan. A score comes from what the candidate said, wrote and built, measured against the skills you picked for the job, the weightage you set on each one and the job description. Integrity signals sit beside that evidence. They do not move a score on their own, and they never close a candidate's file.

See it in the product

The signal captured, then the signal reviewed.

Two screens, one story. The first is the sandboxed coding assessment while the candidate is still in it. The second is what a reviewer opens once the round is over. There is no separate integrity console to remember to check.

Coding assessment
Sandboxed coding test
16:07 End
1Coin Change (Minimum Coins)
Python 5 of 5 passed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def min_coins(coins, amount):
dp = [float("inf")] * (amount + 1)
dp[0] = 0
for c in coins:
for x in range(c, amount + 1):
dp[x] = min(dp[x], dp[x - c] + 1)
if dp[amount] == float("inf"):
return -1
return dp[amount]
 
# greedy fails on coins like [1, 3, 4]
def solve(lines):
n, amount = map(int, lines[0].split())
coins = [int(t) for t in lines[1].split()][:n]
return min_coins(coins, amount)
 
if __name__ == "__main__":
print(solve(sys.stdin.read().splitlines()))
5/5test cases passedComplexity O(n·k)
Sample 112ms
Sample 29ms
Edge: no solution11ms
Large amount31ms
Single coin8ms
Custom input (optional)
stdin for a manual Run
Run Submit

In the round.

The assessment header carries a Proctored badge with the live tab-switch count, sitting next to the timer and the End control. The candidate sees the same count the reviewer will read later.

Proctored (3 switches)

On the report.

The same round arrives as a share-ready reportcard: the score, the verdict, a score on each skill drawn from the transcript and the code, the recording, a searchable transcript, and the round's malpractice status.

Malpractice · None, no tab switches flagged

Product screens shown with sample data. Candidate names and companies inside Expert Hire mockups are invented.

See a sample report, flags and all
Two levels of proctoring

Browser proctoring for volume. The desktop app for the rounds that decide.

Maximum strictness on every round loses good candidates at the top of the funnel. There are two levels, so the friction matches the stakes. Both feed the same reviewer view.

Web proctoring

Runs in the browser. Nothing to install.

The candidate opens a link and starts. Integrity signals are collected in the round without adding a download step in front of someone who is still deciding whether to apply.

  • Right for the first screen and high-volume funnels
  • No install, so drop-off stays where it was
  • Signals still land on the report a reviewer reads

Use it when the cost of a false negative is one more round.

Desktop proctoring app

Strict rounds, in one controlled place.

A cross-platform desktop app runs strict-proctoring rounds. Video, the code editor and security monitoring sit in one app instead of a browser the candidate also lives in.

  • Video, code editor and security monitoring in one app
  • Right for finals, paid assessments and campus exams
  • Unlocks on Growth and Scale, no extra credits per session

Use it when the result decides an offer or goes on a transcript.

The desktop app sits alongside the web app and the Chrome extension on the downloads page. Placement teams running invigilated exams usually start here.

Get the desktop app
From signal to human

How a flag actually reaches a reviewer.

The question is not what the software can spot. It is what happens after it spots something. Here is the path, end to end.

01

The round runs, and signals are collected as it happens.

Overlay-tool detection and tab-switch counting operate while the candidate is working, not in a batch job afterwards. The Proctored badge in the assessment header shows the candidate the same running count.

02

The recording is analyzed once the round ends.

Post-interview video analysis runs against the session and adds what it found to the same record. A reviewer is never comparing two systems that disagree.

03

One report is assembled, with integrity inside it.

The candidate report carries the overall score, a verdict line, a score on each skill drawn from the transcript and the code, the full recording, a speaker-separated searchable transcript with All, Candidate and Interviewer filters, and the malpractice status for the round.

04

A person reads it and decides.

The reviewer plays the moment, reads the transcript line next to it, looks at the code that was actually written, and makes the call. Nothing has been rejected on the way there. Nothing gets rejected without them.

A recruiter can also listen in on a live round without interrupting it, then take over in real time if the moment needs a human in the room rather than a note on a report.

How scoring works
Why we do not auto-reject

A flag is never an automatic verdict.

Wiring a threshold to a rejection email would be easy. It would also be unfair, because integrity signals describe events, not intent. And it would leave you with a rejection nobody can explain.

So we do not auto-reject anyone. Signals are surfaced to a human reviewer alongside the transcript and the code, and the decision stays with the person whose name is on it.

A signal is evidence, not a conclusion.

A tab switch has innocent explanations. So does a dropped frame of video. Software can see that an event happened. Only a person can weigh it against the rest of the round.

Decisions have to be explainable later.

Every score traces back to the transcript, the live code and the skills and weightage set on the job. A decision can be reconstructed months later instead of defended from memory.

The human is the decision maker, not the rubber stamp.

Automated employment decision tools carry real obligations in a growing number of places. A person on the decision with the evidence in front of them is the design, not a disclaimer added at the end.

Candidates are not kept in the dark.

The Proctored badge and its running tab-switch count are visible in the assessment header while the round is happening, so the number a reviewer reads afterwards is the number the candidate already saw.

Encryption in transit and at rest, role-based access control and audit logs on every action sit underneath all of this. SOC 2 and ISO are in progress, and SSO with SAML is on the roadmap.

Where it applies

Any assessment can be proctored, not just the coding round.

Proctoring is a setting you add to a round, so it works on any round type. AI prompt assessments can be proctored too, which matters when the thing being tested is how well someone drives an AI.

Live interviews.

AI voice rounds with Ethan and human-led rounds both produce a recording, a transcript and a score. Integrity signals attach to the same report either way.

See the interview platform

Coding tests.

A sandboxed problem with real execution against hidden test cases, scored on correctness, efficiency and code quality. The proctoring banner and its tab-switch count run in the assessment header while the candidate writes.

See coding tests

Campus exams and drives.

Placement cells run invigilated rounds for a whole batch, then export interview performance and resume reports. Proctored results hold up when a recruiting partner asks.

See campus placements
What it costs

Proctoring costs nothing extra.

Running an assessment under proctoring costs exactly what running it in a browser costs. There is no modifier and no separate meter. The desktop proctoring app unlocks on the Growth and Scale plans.

ActionStandardProctored
Coding test3 credits3 credits
AI interview5 credits5 credits
AI-prompt assessment3 credits3 credits

The two columns are identical on purpose: proctoring is free. Reports and insights stay at 0 credits whether the round was proctored or not.

One pool, not one meter per feature.

Every workspace gets one shared monthly pool of Hire Credits and every action draws from it, so you cannot run out of proctoring while interviews sit unused. Unused plan credits roll over one month. Reports are never metered.

Where proctoring unlocks.

The desktop proctoring app is included from Growth at $499 per month with 2,200 credits, and on Scale. Annual billing is 20 percent less. The free trial runs 30 days with 75 credits and charges nothing in that time.

See pricing
FAQ

Questions about integrity, answered.

What hiring teams and placement cells ask before they turn proctoring on.

Still have a question? Book a demo and we will walk you through a proctored round.

Get started

Run one proctored round and read the report yourself.

Set up a coding test, switch proctoring on, and see what a reviewer gets: the score, the recording, the transcript and the integrity status, in one report.

Book A Demo

30-day free trial with 75 Hire Credits. Card required, nothing charged for 30 days.