How candidates cheat in online technical assessments (and how to catch them)
Cheating in online technical assessments is now an AI problem, not a copy-paste problem. Candidates use ChatGPT to write code, hire stand-ins through Discord servers, run virtual machines to hide secondary screens, and route entire interviews through AI tools that whisper answers in real time. Research from Canvas8 and Multiverse in 2024 found that roughly half of job seekers admit to using generative AI to misrepresent their skills during applications or assessments — a number that has reset what "honest signal" means in technical hiring.
This article covers the tactics candidates actually use, the controls that work against each one, and the trade-offs of every prevention method. Some proctoring techniques degrade candidate experience. Some flag honest candidates. We name those costs where they exist.

Why cheating in online technical assessments matters more now
The cost of a wrong technical hire has not changed much — Forbes reports that replacing an employee can cost roughly 30% of their annual salary, and several multiples of salary for senior engineering roles. What has changed is the volume of unreliable signal entering the funnel.
Three shifts matter:
- AI-generated CVs reach screening stage at a rate that did not exist before 2023. According to a 2024 Neurosight survey reported by The Times, roughly half of graduate applicants are now using AI tools to write or polish their applications, and recruiters increasingly observe LLM-style polishing across incoming resumes for technical roles.
- Coding assessments are the easiest stage to fake. In our experience, a take-home that takes an honest candidate four hours can often be completed by ChatGPT or Claude in a fraction of that time.
- Proxy candidates are organized. Reports indicate that Discord servers and Telegram groups run "interview-as-a-service" pricing for popular companies.
Assessments designed to be a signal filter are increasingly a noise filter. That changes what proctoring needs to do.
The four cheating tactics that matter — and what to do about them

Most cheating in online technical assessments today falls into four buckets. We've ordered them by how often we see them in customer reports, not by sophistication.
Using ChatGPT and other AI tools to write code
This is the most common cheating method on take-home assignments and unproctored coding tests. Candidates paste the problem into ChatGPT, Claude, or GitHub Copilot, copy the output, and submit. For many common algorithmic problems, LLMs frequently produce solutions that pass standard test cases on the first attempt.
What this looks like in practice: a junior backend candidate submits a clean implementation of a graph traversal problem with idiomatic Python, but cannot explain their choice of data structure in the follow-up interview. The code is correct. The candidate isn't.
What works against it:
- Disable copy-paste into the code editor. This catches the laziest attempts and slows down the rest.
- Use problems that require context from a provided codebase rather than standalone algorithms. LLMs do worse when the problem requires reading 200 lines of unfamiliar code first.
- Add a 10-minute follow-up conversation where the candidate explains their solution. Most LLM-assisted candidates fail this within two questions.
- Track typing patterns. A candidate who pastes a complete solution in one keystroke is different from one who writes it. Most assessment platforms flag this, though false positives exist for candidates who draft elsewhere and paste.
Trade-offs to name honestly: restricting copy-paste degrades the experience for candidates who legitimately draft in their own editor. Some senior engineers find this insulting. The fix is to communicate the restriction up front and limit it to junior screens, where the volume justifies the friction.
Hiring a proxy to take the assessment
Proxy candidates are the most expensive form of cheating to detect and the most damaging when missed. The setup ranges from a friend taking the test on the candidate's laptop, to paid services that complete entire interview loops on the candidate's behalf.
What works against it:
- Identity verification at the start of the session — government ID matched against a webcam capture. KYC-grade verification is the standard, not optional. Restrict test access to specific IP addresses when the role is geo-bound.
- Live proctoring for high-stakes rounds (final interviews, senior hires). Recorded proctoring for earlier stages.
- A short live conversation at any point in the loop. Proxies do not survive a 15-minute call with the hiring manager. The economics of paid proxy services don't work if every candidate has to face a real interview.
Trade-offs: ID verification raises legitimate privacy concerns, and in some jurisdictions (parts of the EU, Illinois under BIPA) it requires explicit consent and data-handling disclosures. Don't deploy without your legal team reviewing the consent flow.
Using multiple devices or off-camera help
A second laptop on the desk. A phone in the lap. A friend whispering over Discord through earbuds. This is the in-between tier: more effort than ChatGPT, less commitment than a proxy.
What works against it:
- A 360-degree room scan at the start of the session. Catches obvious secondary screens; doesn't catch a phone under the desk.
- Webcam and microphone monitoring throughout the session. Audio analysis can flag whispered conversations, but accuracy varies and background noise creates false positives.
- Eye-tracking heuristics — candidates whose gaze repeatedly drifts off-screen get flagged. This is signal, not proof. Treat it as a reason to add a follow-up interview, not a reason to reject.
Trade-offs: webcam-based proctoring has documented false positive rates that disproportionately affect candidates with darker skin tones, candidates with certain disabilities, and candidates testing in non-ideal home environments. Bias-audit your proctoring vendor's models before deploying at scale. If your vendor can't tell you how their flagging models were tested, switch vendors. For more on designing fair evaluation processes, see our guide on reducing bias in technical hiring.
Using virtual machines and remote desktop tools
The most technically sophisticated cheating method. The candidate runs the assessment inside a VM, with their host OS free to search for answers, run a second AI session, or share the screen with a remote helper.
What works against it:
- A secure browser that detects VM environments and refuses to start the session. Most modern assessment platforms ship this.
- Detection of remote desktop software (TeamViewer, AnyDesk, Chrome Remote Desktop) running on the host machine.
- Keystroke and mouse-movement analysis that flags non-human input patterns.
Trade-offs: secure browsers don't run on every OS configuration. Linux users, candidates on locked-down corporate machines, and candidates with accessibility tools sometimes can't complete the assessment. Have a fallback proctored option for these cases — usually a live video interview using a tool like FaceCode.
Matching proctoring controls to assessment format
The right control for cheating in online technical assessments depends on the format. Treating all assessments the same is where most proctoring rollouts go wrong.
Async take-home assignments (the candidate works on their own time, with hours or days to complete) cannot be fully proctored. Accept this. The controls that work here are:
- Design problems that LLMs do poorly on — open-ended system design, debugging an unfamiliar codebase, problems that require domain context.
- Always pair the take-home with a live follow-up where the candidate explains their solution and extends it.
- Use the take-home as a "do not waste senior engineer time on this candidate" filter, not as the hiring decision.
Live proctored coding sessions (the candidate works in a fixed window with monitoring) can apply the full proctoring stack. Use these for:
- High-volume campus and entry-level screens where the per-candidate cost of human interviewing is prohibitive. For approaches specific to volume hiring, see our overview of campus recruitment strategy.
- Roles where the role itself involves working in a monitored environment (BFSI, defense, healthcare).
Live video interviews with an engineer (FaceCode-style) need almost no proctoring beyond ID verification. The interviewer is the proctor. The trade-off is engineering time — according to levels.fyi compensation data, senior engineers at major tech companies command total compensation that translates to well over $100/hour fully loaded, making a 60-minute screen for every applicant unaffordable above a few hundred candidates.
Cheating prevention across entry-level and senior hiring
Stopping cheating in online technical assessments looks different at different seniority levels.
For high-volume entry-level and campus hiring, where you screen thousands of candidates for hundreds of offers, automated proctoring with rigorous identity verification is the only economically viable approach. Accept some false positives. Build a human-review queue for flagged sessions. Be transparent with candidates about what is monitored.
For senior engineering hiring, where each candidate is expensive to source and the cost of one bad hire is high, lean on the live interview. Use take-homes as conversation starters, not screening filters. A staff engineer who used AI to draft their take-home and then walks you through the design choices articulately is not the same problem as a junior candidate who pasted ChatGPT output and can't explain it. Modern hiring should be able to tell the difference.
For AI-fluent roles specifically — where the job involves using AI tools — the question isn't whether the candidate used AI on the assessment. It's whether they used it well. The frame shifts from "did they cheat" to "can they do the actual job."
How HackerEarth helps you detect and prevent cheating

If you are dealing with cheating in online technical assessments at scale, the practical question is how to layer controls without slowing the funnel. HackerEarth's proctoring stack pairs with Skill Assessments and FaceCode to address the four cheating patterns above — a secure browser that restricts VM use and copy-paste, KYC-grade identity verification that confirms the candidate is who they claim to be, and session monitoring that flags irregularities for human review. One enterprise customer used the assessment platform to screen more than 2,000 candidates in a single weekend with consistent rubric-applied evaluation.
The proxy-candidate problem in particular is hard to solve with static tests. OnScreen runs structured AI interviews with built-in identity verification and proctoring, so a candidate has to respond to follow-up questions in real time rather than submit pre-prepared work. As described in HackerEarth's OnScreen launch announcement, Pawan Kuldip, Head of HR at Discover Dollar Inc., noted that the team previously struggled with long interview cycles and unreliable shortlists, and reported that after deploying OnScreen, "roles that previously took much longer are now being closed within three to four weeks," with shortlists that more reliably exclude AI-generated and proxy-completed applications.


FAQ
How do candidates use ChatGPT to cheat on coding tests? They paste the problem into ChatGPT or Claude, copy the generated solution, and submit it. For standard algorithmic problems (sorting, graph traversal, dynamic programming), modern LLMs produce correct, idiomatic code on the first try. The tell is usually in the follow-up: candidates can't explain choices in code they didn't write. The defense is not detection software — it's interview design that requires the candidate to extend or debug their own solution live.
Does AI-based proctoring invade candidate privacy? AI-based proctoring collects biometric and behavioral data — webcam recording, room scans, ID verification, keystroke patterns — that carries real privacy implications. In the EU, the UK, and several US states, candidates have legal rights to know what is captured and how it is processed. Treat proctoring consent as a real candidate-experience decision, not a checkbox. Tell candidates exactly what is monitored before they start.
How accurate is AI cheating detection? Mixed. VM detection and copy-paste flagging are close to deterministic. Eye-tracking and audio-based flagging produce meaningful false-positive rates, especially for candidates with disabilities, candidates in shared living spaces, and candidates who naturally look away from the screen while thinking. Treat algorithmic flags as input to human review, not as automated rejection.
Can candidates cheat through AI interviews like OnScreen? The counterintuitive risk isn't the candidate gaming the AI in real time — it's candidates rehearsing scripted answers using LLMs in the days before the interview. Adaptive follow-ups and identity verification limit live cheating, but interviewers should still vary question paths and probe for reasoning behind rehearsed-sounding responses. No system catches every cheater; the goal is to make cheating expensive enough that preparing honestly is the cheaper path.
Should we ban AI tools in assessments entirely? Depends on the role. For roles where the job involves using AI daily — which is most software engineering today — banning AI in assessments tests the wrong skill. Evaluate how the candidate uses AI, not whether they avoid it. For roles where AI use during the job is restricted (regulated industries, security-sensitive work), the assessment should mirror that constraint.
Next steps
Cheating detection reflects a persistent asymmetry: a candidate can adopt a new AI tool in an afternoon, while a hiring team needs weeks to audit, deploy, and tune a counter-control. Any article promising "the solution" is overstating the case. What works is layered defense: design assessments that LLMs struggle with, verify identity with KYC-grade tools, monitor sessions with proctoring you've audited for bias, and always pair high-stakes hires with a live conversation that current AI tools struggle to replicate convincingly in real time.
Schedule a demo of HackerEarth Assessments to see how the secure browser, identity verification, and OnScreen AI interviews work together against the four cheating patterns covered here.










