Recagn
Sign in

Technical screening · Recagn

Coding screening for recruitment agencies

Add a code question to the first-round interview. Recagn reads each candidate's code answers (not run) against the role's rubric and writes out the reasons for each score.

What does coding screening take off your plate?

Recagn asks a code question in the first-round interview and reads every candidate's code against the role's rubric. A recruiter who doesn't read Java still gets the reasons, criterion by criterion, in plain English. You choose the question, read the reasons and decide who goes to the client.

Off your plateStays yours
Asks the code question in the first-round interview, beside the role's other questionsWhich question to ask, and what a good answer needs
Reads every file each candidate submitsWhether the role needs a code question at all
Scores the rubric criteria the question is linked to, and writes the reasoningWhat the scores mean for this client
Tracks pastes into the editor and shows them in your interview review, marked in the file they were pasted intoWhether a paste matters
Puts the code files and the criterion scores, with their reasons, in the client's reportWho goes on the shortlist. Recagn recommends. Only you can reject a candidate.

Source: Recagn's interview, scoring and report code · checked 17 Nov 2026

Recagn does the screening. You make the calls. For what to ask in each role, start with our screening questions for recruiters.

How does code screening work in a Recagn interview?

A code question sits in the interview like any other question, linked to the rubric criteria it gathers evidence for. The candidate writes the answer in a code editor, across up to 10 files. Recagn reads the files and scores the criteria the question is linked to; the code is not run.

In our Senior Java full stack and platform engineer worked example, we added a code question. It asks for an endpoint that returns a customer's 20 most recent orders with their line items, in as few database queries as possible, using Spring Boot, with a unit test and a comment on how to index the tables. The question is linked to two criteria: Java full-stack development, and Databases & SQL.

Rohan D.'s code answer, as Recagn scored it

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();
    }
}
  1. 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.

  2. 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.

Scored by Recagn on 17 Nov 2026 · Senior Java full stack and platform engineer · the code question was added for this example · invented candidate; the code was written for this example · each criterion score also draws on his other answers

Rohan D. answered in four files. OrderQueries.java fetches the 20 orders in one query and all their line items in a second, keeps the limit and the ordering in the SQL, and proposes indexes in a comment. OrderController.java returns "not found" for a customer who doesn't exist. OrderQueriesTest.java tests the queries against a real database. Recagn's reasoning for each criterion is quoted whole in the figure, and it also draws on Rohan's other answers.

Behind that reasoning, Recagn's scorer is told the code was not run and to judge it by reading it. It sees every file with its name and language.

How does a code answer count in Recagn's scores, and who decides?

Recagn scores each rubric criterion from 1 to 5 from all of a candidate's answers linked to it, and a code answer is one of those answers. The role's hard gates and the weighted total then set the recommendation: Qualified, Maybe or Disqualified. You decide who moves on.

Here are the four candidates from the same run, on the one criterion where Recagn's reasoning discusses every candidate's code.

CandidateJava full-stack development (weight 25%)Recommendation
Rohan D.4Qualified
Sneha K.3Disqualified
Vikram S.3Maybe
Arjun M.1Disqualified

Source: Recagn's scores on the Senior Java full stack and platform engineer worked example, run 17 Nov 2026 · invented candidates; answers written for this example · each criterion score also draws on the candidate's other answers to it

Sneha K. scores the same as Vikram S. on Java full-stack development, yet Recagn recommends Disqualified for her and Maybe for him. The difference comes from the rest of the role: her lower scores on the cloud, platform and Linux criteria, and the hard gates she fails. Recagn's one-line summary of her reads: "A strong, honest application-focused Java engineer with excellent SQL and solid React/Spring Boot skills, but lacking the infrastructure, cluster-administration, Linux, and Terraform ownership this platform-engineering role requires, failing three of four gates."

So a code answer is evidence for the criteria it's linked to, and the role's other needs still decide. Recagn recommends. Only you can reject a candidate.

What does a technical screening tool cost?

A Recagn interview with a code question, no video answer and no webcam proctoring uses one credit, the same as a text interview: at most ₹49.98 a text interview on Starter (₹58.98 with 18% GST). That is a ceiling, not an average, because the plan also pays for CV matching. The code question itself adds no credits.

Recagn uses credits only when it scores a submitted interview, so a candidate who never starts costs nothing. Starter is ₹2,999 a month before GST, and plan detail is on Recagn pricing. The coding-test vendors that publish prices charge about ₹926–2,994 per assessed candidate on their smallest monthly plans (checked 17 Nov 2026, GST not stated). HackerEarth's Growth plan, $99 a month or $9.90 a credit, carries no proctoring: HackerEarth's pricing page ticks proctoring on Scale and Enterprise, not Growth.

RecagnOur productCodilityHackerEarth AssessmentsHackerRank
Smallest monthly planStarter, ₹2,999 a month$800 a month, 25 invitesGrowth, $99 a month, 10 creditsStarter, $83 a month, 5 candidate attempts
Per candidateOne credit for a code interview with no video answer or webcam$32 an invite, about ₹2,994$9.90 a credit, about ₹926, no proctoring$16.60 an attempt, about ₹1,553
TaxBefore 18% GSTGST not statedGST not statedGST not stated
How the code is handledRead and scored against the role's rubric (not run)Claude Code and Codex "in the terminal"Run against hidden test cases, scored by the cases it passes"Full IDE (terminal, file navigation)"
Recagn is listed first because this is our page; the rest are alphabetical. The order is not a ranking.

Source: HackerEarth pricing, HackerRank pricing, Codility pricing, checked 17 Nov 2026, monthly billing · USD at ₹93.56 (Wise mid-market, 17 Nov 2026) · Recagn from its plan catalogue

A HackerEarth credit, a HackerRank attempt and a Codility invite are each one candidate taking a coding test. A Recagn credit is a whole first-round interview whose code is read, so the per-candidate row compares units, not like-for-like products.

What do candidates see in a code question?

Candidates see the question and a code editor in their own browser, with tabs for up to 10 files and highlighting for 20 languages. Under the editor, Recagn tells them "Code isn't run in this Interview." Pastes into the editor are tracked with the file name and marked in that file in your interview review.

The editor has no autocomplete, and an answer holds up to 100,000 characters across its files. There is nothing to install. On a phone, candidates see a hint once, "Code is easier to write on a computer.", and their saved answers carry over if they open the link on a computer.

The same interview can add webcam proctoring, an ID check by face match and screen recording. What each one records is set out on Recagn's AI proctoring page, and when a paste becomes a flag is set out in the Integrity rules.

When is Recagn the wrong choice for coding screening?

Recagn is the wrong choice when you need code scored by the test cases it passes, or candidates working in a full IDE with a terminal. Recagn screens developers in a first-round interview that a recruiter reads and a client receives.

  • Pick Codility if candidates should work in a terminal with AI coding tools such as Claude Code and Codex, as on Codility's pricing page (read 17 Nov 2026).
  • Pick HackerEarth if you want code scored by the hidden test cases it passes, as HackerEarth's help centre describes it (read 17 Nov 2026).
  • Pick HackerRank if candidates should work in a full IDE with a terminal and file navigation, as on HackerRank's pricing page (read 17 Nov 2026).
  • Pick Recagn to put a code question into the same interview as the role's other questions, scored on one rubric, with the client's report ready at the end.

Features vary by plan. See pricing.

Questions people ask

If the code isn't run, how does Recagn know it works?

Recagn judges it by reading it, as a reviewer reading a pull request would. Its scorer is told the code was not run, reads every file with its name and language, and scores the criteria the question is linked to, writing down why, as in Rohan D.'s reasoning above.

Can a candidate paste code from ChatGPT into the answer?

They can paste, and Recagn records it. Pastes into the editor are tracked with the file name and shown in your interview review, marked in the file they were pasted into, for you to judge. This sits separately from the score: it isn't used in scoring or ranking. What turns pastes into a flag is in the Integrity rules.

How is this different from a HackerEarth coding test?

HackerEarth runs the code against hidden 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) and scores the rubric criteria it's linked to, beside the rest of the interview.

What does a video answer or webcam proctoring add to a code interview's cost?

A video answer makes the whole interview three credits: at most ₹150 on Starter before GST (₹149.95; ₹176.94 with 18% GST). Webcam proctoring adds credits on top: one for Snapshots, or two for the first 60 minutes of Continuous, then one credit per 30 minutes begun. The code question itself adds nothing either way. Plans and credits are on Recagn pricing.

Which languages can candidates write in?

Twenty, plus plain text. They include Java, Python, JavaScript, TypeScript, Go and SQL, with up to 10 files per answer. The editor highlights code and has no autocomplete.

See it run on one of your roles.