How to stop cheating in online coding tests without punishing honest candidatesSkip to content

How to stop cheating in online coding tests without punishing honest candidates

More monitoring won't stop cheating in coding tests. A test is only cheatable when it can be passed without the candidate. Here's how to design one that can't, and keep it fair.

Dhruv Sanjay Rao, Head of ProductUpdated 7 min read

When teams start worrying about cheating in coding tests, the first answer is usually more watching: a webcam, screen recording, tab-switch alerts, a list of everything that looks suspicious. It feels like control. It mostly isn’t.

The worry is real. In a Gartner survey of 3,000 job candidates, reported by HR Dive, 6% admitted to interview fraud, either posing as someone else or having someone pose as them. The FBI has warned employers about remote applicants using “artificial intelligence and face-swapping technology during video job interviews”. And every candidate now has a tool that writes passable code in seconds.

But a coding test exists to answer one question: can this person do the work? Cheating is only a problem when the test can be answered without the person. So the strongest defence isn’t catching people. It’s a test that’s pointless to outsource, taken by the same person you later interview, with monitoring that raises questions rather than answering them. Get that right and honest candidates barely notice the safeguards. The ones who cheat find they haven’t gained much.

What watching can and can’t see

Proctoring is good at the obvious. A chatbot open in another tab shows up as repeated tab switches. A pasted answer shows up as a paste. A phone held up to the camera, or a second face in the frame, is visible.

It’s much weaker against the tools that matter now. CNBC described an overlay tool sold specifically as invisible to screen-detection software. Someone helping through remote-desktop software may leave nothing a camera can see.

And watching has a cost. Software can’t tell cheating from being human. Candidates look away to think, sit in shared flats where someone walks past, borrow laptops with poor webcams, and lose power halfway through. Treat every one of those as a red flag and you’ll mostly catch honest people, who are the overwhelming majority, while the determined cheat uses a tool you can’t see anyway.

Monitoring is worth having. It just can’t be the plan.

Make the test hard to hand to someone else

Most cheating prevention happens when you write the test, long before anyone is watched.

Popular public problems are the easiest to look up and the easiest for an AI model to solve. A problem built around your own domain, with your own kind of data and awkward edge cases, is much harder to outsource. Judge it on hidden test cases too, because code that only passes the visible examples isn’t working code, and memorised answers tend to miss edge cases. In a large drive, assume questions get shared within days, so keep several equivalent questions in rotation.

Keep the test short. An hour or less is fairer to candidates who already have a job, and leaves little room to relay questions to a helper.

Then tell candidates, up front, that the next round includes a conversation about the code they wrote. That one sentence probably prevents more cheating than any camera, because it makes outsourcing the test pointless. Whoever wrote the code has to be the one who can explain it.

Or let them use AI, openly

There’s another way to remove the incentive to cheat: allow the tool. Canva replaced one of its coding rounds with an AI-assisted one after finding that “AI assistants can trivially solve traditional coding interview questions”. It now sets larger, more ambiguous problems and looks at whether candidates can break down the requirements and catch what the AI gets wrong.

If your engineers use AI every day, this tests the job as it’s actually done. Problems need several reasonable answers rather than one known one, and what you assess is judgement: clarifying what’s being asked, choosing a design, and spotting the plausible-looking line that’s wrong. And once AI is allowed, there’s no point watching for it. Monitoring only has to cover identity and help from another person.

The conversation is the real test

Whatever format you choose, the most reliable check is a person talking to the candidate about their own work.

Ask what happens on a particular line if the input is empty. Change the problem: “the data now arrives as a stream, what changes?” Someone who wrote the code, or genuinely understood what the AI wrote, adapts. Someone reading from a hidden screen tends to stall the moment the problem moves away from what they were given.

Interviewers often notice other things too. Vault lists the signs: unusually polished language, noticeable delays even on routine questions, candidates “reading rather than listening”, and answers that fall apart on follow-up. Treat these as reasons to ask more, never as proof. Nerves, a second language and a well-rehearsed answer can look exactly the same. Write down what you saw (“couldn’t explain the recursion they wrote”), not what you concluded (“used ChatGPT”), and if doubt remains, offer another round with a different interviewer rather than rejecting on suspicion.

Check it’s the same person at every stage

Impersonation tends to happen at the handover between stages: one person takes the test and another turns up to the interview, or the reverse. The FBI’s advice to employers is to verify identity “across multiple stages”, not just once.

That doesn’t need anything elaborate. Check ID against the face on camera at the first live round, and make sure it’s the same person later and on joining day. Ask about their own test. Anyone who sat it will recognise the problem and their approach. Keep at least one familiar face across rounds. And look for the same phone number or email turning up under “different” applicants in a drive. Tell candidates in advance that you’ll check ID, so it reads as routine rather than an accusation.

A flag is a question, not a verdict

Every automated signal, whether it’s a tab switch, a second voice or two submissions that look alike, should lead to a person looking at the evidence, not to a rejection. Even dedicated code-similarity tools say this about themselves: Stanford’s MOSS documentation notes that the tool “has no way of knowing why codes are similar” (MOSS). Short solutions to standard problems often look alike.

The fair process is short. Warn the candidate the first time something looks wrong, so an accidental tab switch can be corrected. Count sustained or repeated behaviour, not one odd moment. Then attach what was actually seen, have a person review it, and where it’s unclear, ask the candidate. Most flags have innocent explanations, and the ones that don’t usually become obvious in the conversation.

Tell candidates before you watch them

Send the rules with the invitation, not on the test screen. Say what you’ll monitor (only what you’ve actually switched on), which tools and what help are allowed, what you keep, for how long, and who sees it. Tell candidates how to ask for an adjustment, like extra time or a test without a camera, and plan those before the day, not during it. Clear rules mean honest candidates make fewer accidental mistakes, and nobody can claim they didn’t know.

Webcam images are personal data, and data protection law, including India’s DPDP Act, expects consent that is clear and specific. In practice: ask before monitoring starts, make saying no as easy as saying yes, keep only what a reviewer needs, and delete it on a schedule. This is general guidance, not legal advice.

Why this breaks down in a campus drive

On paper, none of this is complicated. Now try running it for four hundred candidates in a week.

Questions go out in a shared document and are on a Telegram channel by the evening. Someone runs submissions by hand to see which pass. Suspicious moments end up as screenshots in a recruiter’s downloads folder, with no way to tell which candidate they belong to. The person who took the test and the person who joins the interview are matched by name in a spreadsheet, if at all. When a candidate disputes a rejection, there’s no evidence to show them, just someone’s memory of a feeling.

Fairness at volume depends on consistency: the same rules, the same warnings, the evidence stored against the right candidate, and a person reviewing every flag. That’s very hard to do by hand, and very easy for a system to do every time.

How Arexis helps

In Arexis, candidates take a timed coding test in their browser, drawn from a bank of over 1,500 questions, and their code is checked in a sandbox against hidden test cases. When you switch proctoring on, one incident counts as one strike, against a limit you set, and each strike can carry the evidence (a still frame, a short audio clip or a screenshot) for a person on your team to review. Nothing rejects anybody automatically. See coding tests and proctoring.

Found this useful? Pass it on.

See it on your own roles.

Screening, scheduling, interviews and proctored coding tests in one workspace. 30 days free, no card.