A stock coding test treats every candidate the same.
Build one for the role you’re actually hiring.

A code-review exercise tailored to your stack and seniority — plus the weighted scorecard your interviewers use to grade it consistently.

$69 per role. No subscription.

Why this beats a stock test

Built for your role, not pulled off a shelf.

Calibrated to the actual role

An off-the-shelf test gives a junior and a staff engineer the same puzzle. A tailored exercise matches the seniority — and the work the person will really do.

Reflects the team they’d join

Generic tests ignore your stack and your domain. Assay builds the exercise around the role, company, and team context you provide, so it probes what matters here.

Scored to a decision

A pass/fail score still leaves you guessing between two candidates who both passed. Every exercise ships with a weighted scorecard, so the result is a judgment you can stand behind.

A real output

A real code-review exercise — see it before you sign up.

A code-review exercise Assay generated for a senior backend role: a real module with planted issues, plus the weighted scorecard your interviewers use to grade it consistently.

Tailored to:Senior backendPythonPostgreSQLpgvector
ExerciseCode review · Python

Geospatial candidate search

Review this module, identify bugs and inefficiencies, and suggest improvements for production readiness.

python
import psycopg2
from psycopg2.extras import execute_values
from typing import List, Dict, Tuple


class CandidateSearchService:
    def __init__(self, db_host: str, db_name: str, db_user: str, db_password: str):
        self.connection = psycopg2.connect(
            host=db_host,
            database=db_name,
            user=db_user,
            password=db_password,
        )
        self.cursor = self.connection.cursor()

    def find_candidates_in_radius(self, latitude, longitude, radius_km, job_embedding):
        # Find candidates within a geographic radius, ranked by skill similarity.
        query = f"""
            SELECT candidate_id, name, email, location, skill_embedding,
                   ST_Distance(location::geography, ST_Point({longitude}, {latitude})::geography)
            FROM candidates
            WHERE ST_DWithin(location::geography, ST_Point({longitude}, {latitude})::geography, {radius_km})
            ORDER BY distance_km ASC
        """
        try:
            self.cursor.execute(query)
            results = self.cursor.fetchall()
Scoring rubric · what a strong answer looks like100 pts
  • SQL injection & securitySpots the f-string SQL injection and parameterizes with %s placeholders.
    25 pts
  • Connection & resource managementRecommends pooling and context managers so connections can’t leak.
    20 pts
  • Vector similarity efficiencyMoves cosine similarity into pgvector’s distance operator instead of Python.
    20 pts
  • Error handling & loggingReplaces print() with structured logging and appropriate levels.
    15 pts
  • Documentation & type hintsTightens vague type hints and documents the returned shapes.
    10 pts
  • Edge cases & data validationValidates negative radius and mismatched embedding dimensions.
    10 pts
In one generated guide

The exercise, plus everything you need to score it well.

  • A code-review exercise built for the role

    A realistic module shaped by your role, seniority, and stack — yours to edit, share, and reuse.

  • A rubric that tells interviewers what “strong” looks like

    Competency by competency — so any interviewer grades the same way.

  • Supporting interview questions

    Non-leading, non-loaded, open-ended questions to probe around the code and judge the whole candidate.

  • Cross-candidate comparison view

    Structured scoring that makes candidate-to-candidate comparison honest and defensible.

Why this works

A consistent exercise, scored to a clear rubric, predicts job performance far better than a one-off test read on instinct.

That’s the finding decades of industrial-organizational psychology keep landing on: structure and a shared scoring standard are what make an evaluation predictive. Assay bakes that in — so a tailored exercise plus its scorecard does more than a generic test score ever could, without you reading the research to get there.

Stop guessing after the test.

Generate a code-review exercise built around your role and stack, with the scorecard to grade it — in a few minutes. See it first, decide after.

Build your first code-review exercise