Around 92% could answer technical multiple-choice questions, but roughly 4.4% could produce a fully working, efficient program in the coding-specific results of a 2019 Aspiring Minds study of Indian engineering students, reported by Scroll. For hiring leaders, that contrast changes the question from whether candidates recognise programming concepts to whether they can use them.
Why Recall Quizzes Overstate Coding Skill
Marks and quiz scores can overstate readiness when employers treat recognition as evidence of execution. Choosing the definition of recursion doesn't demonstrate that a candidate can write a terminating recursive function, handle unexpected input or explain why their solution slows down.
A recall question offers candidates the answer somewhere on the screen. A practical task asks them to construct an answer and accept responsibility for what happens when it runs. Those are different demands.
Define the evidence you need
A useful coding assessment question requires an executable response that reveals syntax, debugging, logical correctness, efficiency and the ability to turn a concept into working software. The question should resemble a decision the person will make at work, even when the surrounding task is deliberately small.
Say you're recruiting a junior developer who will maintain an application that processes customer orders. Asking them to identify a dictionary definition tells you little about whether they can prevent duplicate orders. Asking them to implement duplicate detection exposes their choice of data structure, handling of missing identifiers and interpretation of the requirement.
Practical rule: If the answer can be memorised without understanding what the program does, it shouldn't decide who advances.
The comparison behind the recall-versus-execution gap is useful context, not a current pass-rate target for your applicants.
Separate coding from adjacent skills
Your assessment shouldn't accidentally become an English comprehension test or a contest in remembering library syntax. Keep the problem statement plain, define business terms and distinguish an implementation mistake from a misunderstood instruction.
Place coding inside a broader competency assessment test framework. Programming evidence can sit alongside communication and collaboration evidence without allowing a polished verbal answer to erase a non-working submission.
For recruiters, the practical decision is straightforward: ask the engineering manager what successful execution looks like before selecting a question. If they can't name the behaviour or output the item predicts, remove it.
Reject any item whose only purpose is to test familiarity with terminology. Keep concept checks only when candidates must apply the concept.
Question Types Time and Difficulty at a Glance
Coding question types, time and pass signals
The timings below are a proposed assessment design, not measured industry benchmarks. Pilot them with your own tasks before using them to reject applicants.
| Question type | What it tests | Time | Difficulty | Pass signal |
|---|---|---|---|---|
| Concept check | Recursion, a data structure or Big-O, plus an applied example | Suggested 8–10 min | Easy | Correct idea and a correct application |
| Implementation | A function built to a stated complexity target | Suggested 30 min | Medium | Compiles and passes core cases at the target complexity |
| Debugging | An off-by-one error, null failure or inefficient nested loop | Suggested 20–25 min | Medium | Names the defect and ships a working fix |
| Scenario modification | Adapting working code to a new business constraint | Suggested 30–40 min | Hard | New behaviour holds and existing cases still pass |
An India-based analysis of more than 55,000 engineering students from over 250 colleges found that more than 80% struggled to apply programming concepts to real-world situations, according to Aspiring Minds' programming learning-level analysis. That makes transfer from explanation to application the central design problem.
Select tasks from the job description
For a hypothetical fresher or junior screen, reserve 70–90 minutes for a concept check, implementation and debugging, including reading, setup and submission time. Use the concept item to establish understanding, the implementation to observe construction, and the debugging task to see whether the candidate can inspect unfamiliar code.
For a hypothetical product-engineering screen, reserve 90–120 minutes and add a scenario modification. Keep the scope small enough that candidates can demonstrate judgement rather than spend the session discovering undocumented project configuration.
These are starting allocations. If competent internal engineers repeatedly run out of time because of setup, fix the environment before tightening the candidate threshold.
Difficulty should come from the work, not obscure wording. Entry-level tasks can focus on decomposition, patterns, variables, conditions and simple debugging. Experienced applicants can face data-structure choices, complexity constraints, maintainability and changes that must preserve existing behaviour.
Keep the signals separate
Record conceptual accuracy, functional correctness, complexity compliance, debugging diagnosis and code quality separately. A candidate who explains Big-O accurately but ships incorrect code has demonstrated knowledge, not complete implementation competence.
Conversely, a working solution with an uncertain explanation deserves a targeted follow-up rather than an assumption that the candidate guessed. Ask them to trace the program on a new input and explain what changes as the input grows.
Watch for these design traps:
- Pattern-only puzzles: Candidates can recognise a rehearsed solution without understanding the underlying requirement.
- Sample-only marking: Passing the example in the prompt doesn't establish behaviour at boundaries.
- Speed-based ranking: Finishing first doesn't establish that the candidate chose a safe or maintainable approach.
Tick the table rows that correspond to work in the job description. Don't include scenario modification merely because it makes the assessment look more demanding; include it when adapting existing software is part of the role.
How to Design Write and Score Each Question
Begin with the work product, not a favourite algorithm. A recruiter should be able to explain why the task belongs in the hiring process without referring to how prestigious or difficult it sounds.
Build the item in a fixed sequence
Write the job outcome. State what successful performance would predict, such as fixing a billing defect or processing an incoming file without losing records. Remove outcomes the employee won't own.
Choose a question type and a language the team ships. For a language-agnostic role, offer supported language choices with equivalent libraries and runtime conditions. Don't make familiarity with an incidental framework a hidden requirement.
Draft an explicit contract. Specify inputs, outputs, valid ranges, invalid-input behaviour and the complexity target where relevant. Include a worked example showing why the expected output follows from the input.
Build visible and hidden tests before releasing the prompt. As a practical starting design, use three to five visible tests and at least three hidden cases covering empty input, boundaries and invalid data. Hidden tests should check disclosed requirements, not introduce surprise rules.
Publish the time allowance and permitted resources. State whether candidates may consult documentation, use their own editor or ask clarification questions. Provide the same clarification to everyone taking that version.
Pilot for ambiguity and access. Have internal engineers solve the task independently and record where they hesitate. If candidates from a narrow institutional background consistently interpret the wording differently, investigate assumed terminology and preparation exposure rather than treating the item as automatically valid.
Score in stages. Establish whether the submission runs, assess its outputs, inspect its efficiency, then evaluate maintainability. Preserve the stage-level evidence even when your system also produces an overall score.
Staged scoring rubric for a coding question
| Stage | What earns the band | Do not do this |
|---|---|---|
| Compilation and syntax | The program builds and runs | Score a compile failure like a slow correct solution |
| Correctness | Visible and hidden edge cases pass | Mark only the sample shown in the prompt |
| Efficiency | Meets the stated complexity limit | Treat typing speed as engineering skill |
| Maintainability | Clear names, small functions, safe handling of invalid input | Give full marks for a one-line hack that hides the logic |
The procedure keeps question construction and marking connected.
Set thresholds against the role
In an assessment covering more than 36,000 engineering students from over 500 Indian colleges, more than two-thirds couldn't produce compilable code, while just 1.4% produced code that was functionally correct and efficient, according to Business Standard's account of the Aspiring Minds study. A binary result would conceal important differences between those outcomes.
For a production role, make correctness on all designated core cases a required gate. For product engineering, add the published complexity limit. Treat maintainability as an observable judgement, supported by examples from the submission.
A high total shouldn't compensate for failing a requirement that's essential to the job.
Record these gates in an interview scorecard so reviewers apply the same decision rules. Distinguish platform failures from candidate failures, and don't change thresholds after seeing an applicant's college or CV.
When comparing different question versions, calibrate their difficulty through pilots. Equal percentages on unequal tasks aren't equivalent evidence.
Sample Coding Assessment Questions with Rubrics
Say your hiring team needs an assessment bank for applicants with different levels of experience. The following hypothetical exercises use proposed timings and marking schemes; they're templates to adapt, not validated hiring cut-offs.
Fresher exercise on explanation and conditions
Suggested time: 10 minutes. A reporting utility needs to total a list of integers.
Ask the candidate to explain in plain language why visiting every list item to calculate its sum takes O(n) time. Then ask them to write sum_values(values), returning zero for an empty list and raising the language's standard argument error for a null list.
Proposed marking out of 10 points:
- Explanation, 4 points: Connects running time to the number of elements visited.
- Execution, 4 points: Runs correctly on ordinary and empty lists.
- Clarity and protection, 2 points: Uses a meaningful name and an explicit null guard.
A useful follow-up is to ask whether negative values change the algorithm. The candidate should separate the values being added from the number of additions.
Junior exercise on selecting a pair
Suggested time: 30 minutes. A ticketing service stores available seat prices as positive integers.
Ask candidates to return the indices of distinct seats whose prices sum exactly to a supplied budget, using O(n log n) time or better. Return an empty result when no pair exists; when several pairs qualify, any valid pair is acceptable.
Avoid asking for the cheapest pair when every valid pair has the same total. That wording adds ambiguity without testing a useful skill.
Proposed marking out of 10 points:
- Compilation, 2 points: The submitted function builds and runs.
- Correctness, 4 points: Handles ordinary inputs, duplicate prices and no valid pair without reusing a seat.
- Efficiency, 2 points: Meets the stated target.
- Readability, 2 points: Uses clear variables and helpers where they improve understanding.
Experienced exercise on repairing billing code
Suggested time: 35 minutes. Provide a runnable billing function that incorrectly processes the final invoice line twice.
Ask candidates to diagnose and fix the boundary error, then add a tax_exempt flag to each line. Supply the tax rate as an input and specify that exempt lines contribute their base amount but no tax.
Proposed marking out of 10 points:
- Diagnosis, 3 points: Explains why the final line is counted twice.
- Repair, 3 points: Produces correct totals on hidden invoices.
- Extension, 2 points: Implements exemption and adds a regression case.
- Efficiency, 2 points: Preserves a single pass rather than adding a nested scan.
The Press Information Bureau announcement sets out CBSE's planned Computational Thinking and Artificial Intelligence curriculum for Classes III–VIII beginning in the 2026–27 academic session. Earlier exposure to concepts shouldn't be confused with production competence: keep the fresher exercise focused on reasoning and conditions, and reserve the billing task for applicants expected to maintain software.
As a proposed maintenance schedule, review the bank quarterly for language, framework and role fit. Investigate items completed only by a narrow college group, then rewrite or retire those that rely on preparation privilege rather than job capability.
Fairness Anti-Cheating and AI Use Rules
Choose an AI-use mode before inviting candidates. A blanket ban and an unrestricted take-home task answer different questions, and neither is suitable for every role.
- Closed-book fundamentals: Prohibit generative AI for a tightly scoped baseline-reasoning task. State whether ordinary documentation is also restricted.
- AI-permitted workflow: Allow assistance, but require candidates to submit relevant prompts, tests they ran and examples of output they rejected.
- Structured follow-up: Ask candidates to explain a trade-off and modify flawed or unsafe code, including a snippet containing a nonexistent API.
Unstop's State of Campus Hiring India coverage reports that AI/ML skills appear in 60–70% of fresher job descriptions, while only 21% of organisations have fully moved away from CGPA-based filtering. Employers should check that their selection methods observe the capabilities they request.
Assess judgement without guessing authorship
In AI-permitted tasks, evaluate verification, security awareness, test selection and recovery from poor output. A candidate who catches an unsafe database query and replaces it has demonstrated something that a finished code file alone won't reveal.
Use a logic test for programmers only where it adds evidence about reasoning. Don't treat it as proof that a candidate independently authored a separate submission.
Set integrity controls that reviewers can explain:
- Protected cases: Use hidden inputs that aren't published with the task, while keeping requirements transparent.
- Consistent access: Provide a fixed submission window, clear resource rules and equivalent tool access.
- Similarity review: Compare suspicious submissions with public solutions, but treat matching code as a review signal, not automatic proof of cheating.
- Human adjudication: Ask a borderline candidate to explain and alter their solution before making an adverse decision.
Publish the rules in the invitation, not after someone breaches an unstated expectation.
Audit who the assessment excludes
An Indian study of AI-supported recruitment identifies how systems trained on historical hiring data can favour Tier-1 institutions, with bias reduction depending on governance and structured intervention. Another automated score isn't a substitute for reviewing the selection process.
A technically correct test still fails as a hiring instrument if it measures test familiarity or pedigree more than workplace capability.
Use plain-language prompts without culture-specific stories. Offer reasonable accommodations, including extra time where appropriate, and hide college names during marking.
Audit pass rates by institution tier, region and language on your review schedule, using appropriately collected information and restricted access. A gap is a reason to investigate task relevance, accessibility and scoring consistency, not proof of a candidate deficit or, by itself, proof of discrimination.
Rewrite prompts and rules when the assessment creates irrelevant barriers. Don't let CGPA overrule a staged coding score.
Run the Assessment Then Decide With the Team
Before opening the next requisition, lock the role's selected question types, the staged rubric with its required gates, and the AI-use instructions. Assign an owner to approve changes so recruiters don't run different versions of the same hiring process.
These artefacts should exist before anyone sees the applicant pool. Otherwise, reviewers can unconsciously move the standard towards the profile they already prefer.
Turn the assessment into an operating workflow
Set up the role and its criteria. The hiring manager names the work outcomes; an engineer confirms that the tasks represent them; the recruiter checks that the invitation is understandable. Record which failures require rejection and which require discussion.
Run an equivalent assessment for each applicant. Keep task versions calibrated, provide the same preparation information and document accommodations. If a runtime outage interrupts a session, preserve the incident record and arrange a fair reassessment rather than treating the incomplete response as evidence of weak coding.
Decide from responses and structured insights. Review what the candidate wrote, what ran successfully and what they explained. A single percentage isn't enough to distinguish a fragile implementation from a dependable one.
Keep accountability with the hiring team
Where automated marking is used, rely on execution tools for compilation and test results. Treat AI comments about complexity or code quality as reviewable suggestions, particularly when the comment doesn't match the submitted code.
At Career Central, our AI coding assessment explores programming skills through technical tasks. Teams can review candidate responses alongside structured insights, with the team making the final decision.
For a hypothetical rollout, pilot a role for two weeks before replacing the existing test. Use that pilot to inspect unclear instructions, environment problems, reviewer disagreements and whether the task produces evidence relevant to the job.
- Recruiter ownership: Confirm that candidates received the correct instructions and access arrangements.
- Technical ownership: Resolve disagreements about execution, complexity and the meaning of failed cases.
- Hiring ownership: Document why the evidence meets or falls short of the role's requirements.
A shared, role-centred framework keeps decisions comparable across reviewers without pretending that software can take responsibility for an offer. Book a demo if you want to examine how assessment evidence fits beside the other selection steps.
Ship the next offer only when the code passed the staged bar and a human agreed the result matches the job.
Career Central offers coding assessments through technical tasks, with candidate responses and structured insights available for team review. Visit Career Central to book a demo and see how this evidence can fit into your role-based selection workflow.