Skip to content

Guide · PreTested

How to run a technical interview without an engineer.

By · · 12 min read

Contents

A technical interview without an engineer on the call is not a compromise. For the first round it is the better design: the recruiter who already knows the role, the team and the candidate runs a structured 30-minute conversation, scores it against a written rubric and hands the hiring manager a report with the candidate’s own words as evidence. This guide is how we do it at ON3 Works, step by step, and what to watch for.

1. Why recruiters are running the technical round now

Two things changed in 2025 and 2026. First, engineers’ time became the bottleneck in every hiring process: a 45-minute screen is an hour and a half of a senior engineer’s day, and most teams can spare that for three candidates a week, not fifteen. Second, the tools recruiters used to fill the gap stopped working. Timed coding tests, LeetCode-style problems and take-home assignments can all be completed with an AI assistant in a few minutes, so a passing score no longer tells you anything about the person who submitted it. (We wrote about why LeetCode and take-homes stopped working separately.)

That leaves the live conversation. A conversation is hard to fake, cheap to run and tells you what the coding test never did: whether the candidate understands what they are doing and can explain it. The only question is who runs it, and a recruiter with a script is a better first-round interviewer than a tired engineer without one.

2. What a first-round technical interview tests

You are not there to judge code. A first round tests four things, and none of them requires you to be able to write software:

  • Knowledge. Does the candidate know the subject the job needs? You hear this in specifics: names of tools, numbers, the particular way a thing fails.
  • Reasoning. When you ask why, is there a reason? When you change the constraint, does the answer change with it?
  • Trade-offs. Do they know what they gave up? Every real technical decision costs something; a candidate who has made one can tell you what it was.
  • Communication. Can they explain a technical decision to someone who did not make it? That is most of the job in any team larger than one.

What a first round does not test is whether the candidate can build the feature. That is the hiring manager’s round, later, with an engineer in it. Your job is to make sure only candidates worth that engineer’s hour get there.

3. Prepare: turn the job description into a script

Everything that makes a non-technical interview work happens before the call. The script is the expertise you bring into the room, so build it with the hiring manager once, then use it for every candidate for the role.

Pick three or four sections from the job description

Read the job description for the nouns that come up most. For a backend role they might be the language, the database, APIs and operations; for a frontend role the framework, state, performance and accessibility. Each becomes one section of the interview. Leave out anything the job description mentions once.

Write two or three questions per section, about decisions

The useful questions are about what the candidate would do and why, not what a term means. “What is an index?” can be answered from memory. “How would you decide which columns to index on a table that every customer queries?” cannot. A good first-round question has a specific situation in it and more than one defensible answer.

Write the listen-for points

This is the step that lets you interview without expertise. For each question, write three or four points a strong answer would cover. Ask the hiring manager for them; it takes ten minutes. During the call you are not judging the answer, you are listening for the points, and ticking them off.

An example section

For a senior backend role in Node.js, one section might be:

QuestionListen for
How would you diagnose rising tail latency in a Node.js service when downstream response times remain stable?Correlates latency with event-loop delay · profiles synchronous hotspots · checks garbage collection and memory pressure · measures before changing anything
You have one API that every customer calls. How do you stop one customer’s traffic slowing down the rest?Rate limiting per customer · queueing or isolation · what they would measure · what they would tell the customer

You do not need to know what an event loop is to hear whether the candidate mentions it, and to ask “why does that matter?” when they do.

Write the rubric before the first interview

Decide what a 3, a 6 and a 9 out of 10 sound like for each section, in a sentence each, before you meet anyone. Otherwise the first candidate sets the scale and the rest are measured against them. The rubric in section 5 is the one we use.

4. Run the call: a 30-minute structure

A first-round screen fits in thirty minutes if you keep to the script. Sixty minutes is right for senior roles with four sections. Either way, the shape is the same:

  1. Two minutes: set the frame. Say what the call is (a structured technical conversation), that every candidate gets the same questions, that you will take notes, and that it is fine to think aloud and to say “I don’t know”. Candidates relax when they know the rules.
  2. Three minutes: their most recent system. “Tell me about the last thing you built that you were responsible for.” You are not scoring this; you are learning the vocabulary they will use for the rest of the call, and finding the real example to come back to.
  3. Twenty minutes: the sections. Five to seven minutes each. Ask the question, let them answer, then follow up. Move on when the listen-for points are covered or when two follow-ups have not produced anything new.
  4. Three minutes: their questions. Note what they ask. Candidates who ask about the codebase, the team’s process or how decisions get made are telling you something about how they work.
  5. Two minutes: next steps. Say exactly what happens next and when. Then end the call and write your notes before you do anything else.

The follow-ups that need no expertise

You can follow up on any technical answer with one of five questions, and they are the most useful minutes of the interview:

  • “Why that, rather than the alternative?”
  • “What would go wrong with that approach? When would you not do it?”
  • “What would change if there were ten times as much traffic (or data, or users, or people on the team)?”
  • “Have you done this on a real system? What happened?”
  • “If you had to explain that decision to a product manager, how would you put it?”

A candidate who understands the subject enjoys these questions. A candidate who has memorised an answer runs out on the second one.

Take notes as quotes, not impressions

Write down what they said, with the time, not what you thought of it. “18:42: I’d put tenant_id first because every query filters on it” is evidence. “Seemed to know databases” is not, and the hiring manager cannot check it. The scoring comes after the call, from the quotes.

5. Score: the same written scale for every candidate

Score each section 1–10 against a written rubric, straight after the call, from your notes. The scale we use has six levels, and the words matter more than the numbers:

ScoreLevelWhat it sounds like
1–2IncorrectWrong or absent; could not engage with the question.
3–4PartialKnows the words; covered one listen-for point; no reasons when asked why.
5–6CompetentCovered most points with reasons; needed prompting for the trade-offs.
7–8StrongCovered the points unprompted, named the trade-offs, gave a real example.
9ExpertAll of the above, and corrected or sharpened the question’s own assumptions.
10ExceptionalTaught you something the hiring manager will want to hear. Rare by design.

Three rules keep the scores honest. Every score quotes the sentence that earned it. Scores are given per section, never one overall feeling. And the rubric is written down and used for every candidate for the role, so a 7 on Tuesday means the same as a 7 on Friday.

One more, which we learned the hard way: score knowledge, not delivery. A long question answered briefly by someone who knows the subject is a high score. A long, fluent answer that never reaches the listen-for points is not.

6. Red flags, and the false alarms that look like them

Some things are worth a note; some only feel like they are.

Worth a note

  • Jargon without a reason: the right words, but “why?” produces more words rather than a cause.
  • Answers that do not move when the question moves. Change the constraint; the answer should change.
  • No real example anywhere in thirty minutes. Experienced engineers cannot stop telling you about real systems.
  • Reading. Long pauses followed by fluent, generic prose, and eyes that track across the screen, are an answer being typed elsewhere. Ask about their last real system instead; that cannot be looked up.
  • Blaming every past problem on other people.

False alarms

  • Nerves. The first five minutes of most interviews are worse than the rest. Score the whole call.
  • An accent or a second language. Score the content of the answer, not its polish.
  • “I don’t know.” Said once, with a guess at how they would find out, it is a good sign.
  • Disagreeing with the question. If the reason is good, that is a 9.
  • Short answers. Some of the best engineers say the thing and stop.

7. Hand the hiring manager something they can check

The report is the product of the interview, and it is what makes the engineer trust a round they were not in. A report they can check in two minutes has:

  • The score for each section, next to the rubric level it corresponds to.
  • Under each score, the one or two quotes that earned it, with the time in the call.
  • The listen-for points, marked covered or not, so they can see what was asked.
  • A recording or transcript, so any score can be disputed and settled.
  • One line of recommendation: proceed, proceed with a question to probe, or stop.

What it should not have is an overall impression. “Great energy, strong on databases, a bit weak on cloud” cannot be checked and will be ignored by the second hiring manager who reads it.

8. Questions for common roles

Each of these comes with the listen-for points a strong answer covers. They are starting points for your own script; the best questions come from the team’s real systems.

Backend

  • “A request that used to take 50 ms now takes 2 seconds, but only sometimes. Where do you start?” Listen for: measure first · database (slow query, lock, missing index) · a downstream dependency · what “sometimes” correlates with.
  • “When would you not use a relational database?” Listen for: a concrete case · what they would use instead · what they would lose · that they default to relational.

Frontend

  • “The page feels slow on phones but fine on your laptop. What do you do?” Listen for: measure on a real device · JavaScript size and what runs on load · images · what they would cut first.
  • “Where does state live in an app you have built, and why there?” Listen for: local versus shared · the cost of global state · a real example · what they would change.

Data

  • “A dashboard number is wrong and three teams rely on it. Walk me through the next hour.” Listen for: confirm it is wrong and since when · trace the pipeline back · who to tell and when · how to stop it recurring.

DevOps and cloud

  • “Deploys are scary. How would you make them boring?” Listen for: small frequent changes · automated tests and rollback · staged rollout · observability · culture, not only tooling.

9. By hand, or with help

Everything above works with a document, a calendar invite and a video call. The costs are the preparation (an hour per role with the hiring manager), the note-taking during the call (hard while also listening) and the write-up afterwards (twenty minutes per candidate if you are disciplined, longer if not).

PreTested is those three steps as software. It drafts the sections, questions and listen-for points from the job description for you to edit; during the call it shows the current question beside the video and ticks off the points as the candidate covers them, so you can listen instead of writing; and afterwards it scores each section against the rubric above and quotes the evidence, in a report you can change and share. A person leads the whole interview, and the candidate is told how AI is used before they join. The first 3 interviews are free over 30 days, then $49 a month.

Whichever way you run it, the point is the same: the first technical round belongs to the person who knows the candidate, and it should produce something an engineer can check in two minutes. That is a recruiter’s job now, and it is a good one.

10. Questions

Can a non-technical recruiter really run a technical interview?
Yes, for the first round. A first-round technical interview checks whether a candidate knows the subject, can reason about it and can explain their decisions. A recruiter with a prepared script, listen-for points for each question and a written scoring rubric can judge all three without being able to write the code themselves. Later rounds, where engineers go deep on design or review code together, still belong to engineers.
What questions should a non-technical recruiter ask a developer?
Questions about decisions and trade-offs, not definitions: how they would diagnose a specific problem, why they would choose one approach over another, what breaks under load, what they would do differently next time. Each question needs three or four listen-for points written in advance, so you can hear whether the answer covers the ground without judging the code.
How do I know if a candidate is bluffing?
Ask why, then ask what would go wrong. Bluffing survives one question and rarely two. A candidate who understands the subject gives specifics (names of tools, numbers, a story from a real system) and can change their answer when you change the constraints. Vague agreement, jargon without a reason and answers that do not move when the question moves are the signs to note.
How long should a first-round technical screen be?
Thirty minutes is enough for one role-specific section and one general section, with two minutes at each end. Sixty minutes covers three or four sections and suits senior roles. Longer than that, and you are doing the hiring manager’s interview for them.
Should I use a coding test instead?
Not as the first filter. Timed coding tests and take-home assignments can be completed with an AI assistant in minutes, so they no longer tell you who understands the work. A live conversation is harder to fake and cheaper for everyone. Many teams keep a short paired coding exercise, with AI allowed, for a later round.
What does PreTested do that I cannot do with a document and a video call?
Nothing you could not do by hand with enough time. PreTested drafts the script from your job description, shows the questions and listen-for points beside the call and ticks them off as the candidate covers them, then scores each answer against the rubric and quotes the evidence. It saves the preparation and the write-up; the interview itself is still yours.

Run your next technical screen yourself.

No waiting for an engineer, no bot talking to your candidates, and a report your hiring manager can check. Start with three interviews free over 30 days, no card needed.