What can a non-technical recruiter check in a technical screen?
A non-technical recruiter can check evidence: whether the candidate names their own work with numbers, and whether a code answer contains what the client's engineer said it should. Whether the code is well engineered is the engineer's call. Your job is to see that the evidence is there before the client's engineer spends time on it.
For the questions to ask in each role, see screening questions for recruiters, by role.
Three things can be checked without reading a line of code:
- Specific answers. A strong answer about past work names the system, the cause of the problem, the change and the measured result. A weak one names none of them.
- Answers that match the CV. A CV that lists a large platform, beside an answer with no example in it, is two pieces of evidence that don't agree. Ask the follow-up.
- Code that does what the task asked. You can't judge elegance. You can check whether the answer contains each thing on a list the engineer wrote.
What goes wrong is a screen that tests vocabulary. A candidate who can say "microservices" and "Kubernetes" in the right places passes, and the client's engineer finds out early in the next round.
How do you screen developers without coding knowledge?
Screen developers without coding knowledge in four steps: read the job description with the client's engineer, write down what a strong answer shows, ask about the candidate's own work, and set one short code task. The written list is what lets you judge answers you can't evaluate yourself, and it keeps every candidate judged against the same words.
- Ask the client's engineer what the role actually builds, and which one or two skills would sink a hire.
- Ask the engineer for four to six things a strong answer to each question contains, each one something you can find in the answer by name. Do this before the first candidate.
- Ask about the candidate's own work: one system they built, one problem they fixed, with the time or cost before and after.
- Set one short code task the role really does, sized for a first round, and check the answer against the engineer's list.
For a full question set for one role, with what a strong answer shows next to each, see the Java developer screening questions.
Ask them to explain it
Ask the candidate to walk you through what their code does and why, in plain words. An explanation that matches the code and the list is evidence. A fluent explanation that doesn't match is not, and that's the answer to send to the engineer with a note. If the client lets candidates use AI tools while they code, agree the rules first: see whether to allow AI in a coding interview.
What does an engineer look for in a code answer?
In a short code task, an engineer looks at where the work happens, what the code does with missing data, and whether a test proves it works. Comments and confident wording count for little. An engineer reads what the code does, and so can you, if the list names it.
Take a common first-round task: return a customer's 20 most recent orders, with the items in each order. Here is what an engineer would check, in words you can look for.
| What to check | What it means in plain words | What to look for in the answer |
|---|---|---|
| The database does the work | The code asks the database for exactly what it needs, in one or two queries. It doesn't run one query per order (engineers call this "N+1") or load everything and filter afterwards | One or two queries, and no query inside a loop |
| Limit and sorting in the query | "Newest 20" is asked of the database, not worked out after loading every order | ORDER BY and LIMIT, or a page request, in the query text |
| An index proposed | The candidate says which columns the database should index for this query | An index named on the columns the query filters and sorts by |
| Missing data handled | An unknown customer gets "not found", not an error or an empty success | A not-found (404) branch |
| A test of behaviour | The test runs the code against data and checks the result, not only that a method was called | A test with sample data and checks on the output. A test built only from mocks is weaker |
Source: written for this guide from the worked example's code question (below) · not a ranking
The list changes with the task, and the engineer writes it. For a front-end task it might name the loading, error and empty states, and keyboard access. Your job stays the same: find each item in the answer, or note that it's missing.
Read comments against the code. A comment that says "optimised" or "best practices" is a claim, like a line on a CV. The list checks what the code does, not what the comment says it does.
What can't a non-technical screen tell you?
A non-technical screen can't tell you whether code runs, how a candidate designs a large system, or how they work through a problem live with an engineer. Those belong in the client's technical round. The first round's job is to send fewer candidates to it, each with better evidence.
- Whether the code compiles and passes tests. A coding test platform or the client's engineers check that.
- System design at senior and architect level. A short task shows habits, not how someone designs a platform.
- Pairing and live problem-solving. How a candidate thinks out loud with an engineer is a later round.
How Recagn does this
Recagn is our product. We ran a senior Java role through it and added one code question, with the list of what a great answer shows written in. The four candidates are invented, and their answers and code were written for this example. Recagn scored them on 17 Nov 2026.
The question and its list
The question asks for a Spring Boot endpoint that returns a customer's 20 most recent orders with their line items, in as few database queries as possible, with a unit test and a comment on how to index the tables. Candidates write code answers (not run) in an editor, across several files. Here is how a code question works in a Recagn interview.
Every question in a Recagn rubric carries a great answer hint, shown to you as "What a great answer shows". Recagn drafts one for each question it writes from the job description, and you edit it. When Recagn scores, its scorer is told the code was not run, reads every file, and is given each question's hint beside the rubric.
The hint on this question is ours, written for the example: "Code that would compile and run: no N+1 (one join or two batched queries), the limit and ordering done in SQL, a fitting index such as (customer_id, created_at desc), a 404 for an unknown customer, and a test that checks behaviour rather than mocks alone." It is the list in the table above, as an engineer would write it.
One candidate's code answer
Open a file to read the code. Recagn reads it without running it and scores the criteria the question is linked to; each reason also draws on his other answers.
Rohan D. Recommendation: Qualified
Code answer (not run)
Write the Java code for GET /customers/{id}/orders: it returns the customer's 20 most recent orders with their line items, in as few database queries as you can. Use Spring Boot with JDBC or JPA, as you prefer. Include a unit test, and say in a comment how you would index the tables.
4 of 10 files · Java
OrderController.java Java
package com.example.orders;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class OrderController {
private final OrderQueries queries;
public OrderController(OrderQueries queries) {
this.queries = queries;
}
@GetMapping("/customers/{id}/orders")
public ResponseEntity<List<OrderView>> recentOrders(@PathVariable long id) {
if (!queries.customerExists(id)) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(queries.recentOrders(id, 20));
}
}
OrderQueries.java Java
package com.example.orders;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;
/**
* Two queries, whatever the order count: the 20 orders, then all their line items in one IN.
* A single JOIN with LIMIT would cut items, not orders, so the limit runs on orders alone.
*
* Indexes:
* CREATE INDEX orders_customer_recent ON orders (customer_id, created_at DESC, id DESC);
* -- the WHERE and ORDER BY walk this index; no sort, stops after 20 rows
* CREATE INDEX order_items_order ON order_items (order_id);
* -- the IN lookup; add (order_id, id) if item order matters on large orders
*/
@Repository
public class OrderQueries {
private final NamedParameterJdbcTemplate jdbc;
public OrderQueries(NamedParameterJdbcTemplate jdbc) {
this.jdbc = jdbc;
}
public boolean customerExists(long customerId) {
Boolean exists = jdbc.queryForObject(
"SELECT EXISTS (SELECT 1 FROM customers WHERE id = :id)",
Map.of("id", customerId), Boolean.class);
return Boolean.TRUE.equals(exists);
}
public List<OrderView> recentOrders(long customerId, int limit) {
Map<Long, OrderView> orders = new LinkedHashMap<>();
jdbc.query("""
SELECT id, status, total_paise, created_at
FROM orders
WHERE customer_id = :customerId
ORDER BY created_at DESC, id DESC
LIMIT :limit
""",
new MapSqlParameterSource("customerId", customerId).addValue("limit", limit),
rs -> {
long id = rs.getLong("id");
orders.put(id, new OrderView(id, rs.getString("status"), rs.getLong("total_paise"),
rs.getTimestamp("created_at").toInstant(), new ArrayList<>()));
});
if (orders.isEmpty()) {
return List.of();
}
jdbc.query("""
SELECT order_id, sku, quantity, price_paise
FROM order_items
WHERE order_id IN (:ids)
ORDER BY order_id, id
""",
Map.of("ids", orders.keySet()),
rs -> {
orders.get(rs.getLong("order_id")).items().add(new OrderView.Item(
rs.getString("sku"), rs.getInt("quantity"), rs.getLong("price_paise")));
});
return List.copyOf(orders.values());
}
}
OrderView.java Java
package com.example.orders;
import java.time.Instant;
import java.util.List;
public record OrderView(long id, String status, long totalPaise, Instant createdAt, List<Item> items) {
public record Item(String sku, int quantity, long pricePaise) {}
}
OrderQueriesTest.java Java
package com.example.orders;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
/** Runs against a real PostgreSQL (Testcontainers, via the test profile), not mocks. */
@JdbcTest
@Import(OrderQueries.class)
@Sql("/orders-fixture.sql") // customer 1 with 25 orders of 2 items each; customer 2 with none
class OrderQueriesTest {
@Autowired OrderQueries queries;
@Test
void returnsTheTwentyMostRecentOrdersWithAllTheirItems() {
var orders = queries.recentOrders(1, 20);
assertThat(orders).hasSize(20);
assertThat(orders).isSortedAccordingTo((a, b) -> b.createdAt().compareTo(a.createdAt()));
assertThat(orders).allSatisfy(o -> assertThat(o.items()).hasSize(2));
}
@Test
void aCustomerWithNoOrdersGetsAnEmptyList() {
assertThat(queries.customerExists(2)).isTrue();
assertThat(queries.recentOrders(2, 20)).isEmpty();
}
@Test
void anUnknownCustomerDoesNotExist() {
assertThat(queries.customerExists(999)).isFalse();
}
}
- Java full-stack developmentweight 25%
Criterion score, from all his answers linked to it
Recagn's reason: Strong across Java (Spring Boot enterprise APIs with idempotency, versioning) and React (react-query, optimistic updates), with full-life-cycle ownership and measurable performance outcomes (14 min to <3 min). The code answer is clean, avoids N+1 with two batched queries, limits/orders in SQL, 404 for unknown customer, and a behaviour-focused Testcontainers test. Node.js experience is not explicitly shown, which is the main gap preventing a 5; otherwise this is near-expert depth.
- Databases & SQLweight 10%
Criterion score, from all his answers linked to it
Recagn's reason: Deep data expertise on a 40M-row table: diagnosis via EXPLAIN ANALYZE, functional and partial indexing, subquery-to-join rewrite with a dramatic measurable improvement (6s to 90ms), plus connection-pool tuning. Schema design (immutable versioned tables) and thoughtful composite-index reasoning in the code answer reinforce this. Matches level 5 for optimising enterprise databases for performance and scale. NoSQL is not demonstrated, but relational depth and the overall strength justify 5.
Rohan D.'s own comment explains why his answer uses two queries: "A single JOIN with LIMIT would cut items, not orders, so the limit runs on orders alone."
Four answers to the same question
Each row is one item from the hint. Each cell says what that candidate's files do, in the files' words or in Recagn's reasoning.
| Item on the list | Rohan D. | Sneha K. | Vikram S. | Arjun M. |
|---|---|---|---|---|
| One or two queries, no N+1 | Two queries: the 20 orders, then all their items | Two queries: the 20 ids, then those orders with their items | One JOIN FETCH query | Loads every order, then queries the items order by order |
| Limit and order in SQL | Yes | Yes: "paged in SQL" | Ordering in SQL (order by o.createdAt desc). The limit isn't: Recagn's reasoning says the page request "paginates in memory, not reliably limiting to 20 rows in SQL" | No: sorted and cut to 20 in Java |
| Index proposed (the comment, verbatim) | (customer_id, created_at DESC, id DESC) | (customer_id, created_at DESC) | "index all foreign keys and frequently queried columns" | "I would add an index on customer id." |
| Unknown customer | Returns not found | Returns 404 | No check in the code | No check. Recagn's reasoning: "no 404 handling" |
| Test of behaviour | Against a real PostgreSQL: "not mocks" | Calls the endpoint on seeded data and checks the 20 newest and a 404. Recagn's reasoning: "a behavioural test with seed data" | Mocks the repository only | None: "I did not write the unit test because I am not sure how to set up the database for it." |
Source: candidates' code answers and Recagn's reasoning, Senior Java full stack and platform engineer worked example, scored 17 Nov 2026 · candidates invented; answers written for this example · there is no separate code score
The confident comment
Vikram S.'s answer is the one a non-technical reader is most likely to wave through. His main file opens with this comment:
/*
* Enterprise-grade implementation following best practices.
* Uses JOIN FETCH to load everything in a single optimised query.
* Indexing: index all foreign keys and frequently queried columns.
*/
Recagn's reasoning on Java full-stack development reads: "The code attempt uses JOIN FETCH to avoid N+1 which is good, but mixes @RestController and @Service on one class, applies a Pageable to a JOIN FETCH query (which paginates in memory, not reliably limiting to 20 rows in SQL), and the unit test only mocks the repository rather than testing behaviour."
Sneha K.'s file names the same trap and steps around it: "JOIN FETCH with a page would make Hibernate page in memory, so the two are kept apart."
The "single optimised query" comment claimed what the list checks, and the code didn't do it. That is the reading the table above asks you to make: the comment is a claim, and the list is how you check it.
Where the code counts
The code answer is one of the answers each linked criterion draws on, Java full-stack development and Databases & SQL, and it has no score of its own. Each criterion score rests on all the answers linked to it; the rule is in how AI interview scoring works.
Recagn recommends Qualified for Rohan D., Maybe for Vikram S., and Disqualified for Sneha K. and Arjun M. Sneha K.'s code meets the list. Recagn's reasoning calls it "correct N+1 avoidance by splitting into two queries, SQL-side ordering/limit". The role's other needs, set as hard gates, still decided her recommendation. Good code can belong to the wrong candidate for the role.
Reading every file and writing down, criterion by criterion, why each candidate scored as they did come off your plate. What goes on the list, whether the role gets a code question, and who goes to the client stay yours. Recagn recommends. Only you can reject a candidate. For how an agency runs its tech roles this way, see Recagn for IT staffing agencies.
Questions people ask
If Recagn doesn't run the code, can a fluent candidate talk their way past it?
In the worked example above, no. Recagn's reasoning set Vikram S.'s "single optimised query" comment against what his query does, which is page in memory, and against a test that only mocks the repository. Recagn's scorer is told the code was not run, reads every file, and is given the question's great answer hint beside the rubric. Whether a gap like that matters for this client is your call.
Do I still need HackerEarth or another coding test if Recagn reads code?
Yes, if the client wants code run against test cases. HackerEarth runs a coding answer against test cases and scores it by the cases it passes, going by HackerEarth's help centre, read 17 Nov 2026. Recagn reads the code (not run) in the first-round interview, beside the candidate's other answers, and scores the rubric criteria it's linked to. Many agencies can use both: Recagn's interview in the first round, the client's coding test for the shortlist.
Does a code question cost extra on Recagn?
No. Recagn charges per interview, not per question, so adding a code question leaves the interview at one credit when no answer is video and webcam proctoring is off: at most ₹50 on Starter before GST (₹49.98; ₹58.98 with 18% GST). What raises it is a video answer, which makes the interview three credits, at most ₹150, or webcam proctoring.
Should I ask a developer to explain their code to me?
Yes. Ask what the code does and why they chose it, in plain words, and check the answer against the engineer's list. An explanation that matches the code is evidence. A fluent one that doesn't is a reason to ask the client's engineer to look.