Work Sample Test: The Assignment That Predicts Job Performance
What is a work sample test?
A work sample test is a hiring assessment that replicates a real task the candidate will perform in the role. Unlike interviews that rely on self-reporting or whiteboard puzzles that test abstract reasoning, a work sample test measures job-relevant skill directly. It ranks among the highest-validity selection methods in personnel research: validity 0.33 in the corrected 2022 reanalysis by Sackett et al., revised down from 0.54 in the original Schmidt & Hunter (1998) meta-analysis.
TL;DR
- -Work sample tests are a top-tier predictor of job performance (validity 0.33, Sackett et al. 2022; 0.54 in the older Schmidt & Hunter 1998 figure that the 2022 reanalysis corrected downward).
- -Structured interviews now rank highest in the corrected data (0.42), so the strongest hiring pipeline pairs a structured interview with a work sample test — not one instead of the other.
- -Every effective test has six components: role context, task, input materials, deliverable, constraints, and an evaluation rubric with behavioral anchors.
- -The rubric — not the assignment itself — is what converts assessment from subjective judgment to objective measurement; 4–6 criteria with behavioral level descriptions is the standard.
- -AI generates a complete first-draft work sample test in minutes from a structured prompt; the team adapts it, pilots it with a current employee, and calibrates scoring before using it with candidates.
- -Critical process rules: 2–4 hour maximum scope, assignment updated every 3–6 months (they leak), and all candidates get the same assignment for comparability.
A work sample test measures skill directly, not through a proxy. The candidate does a slice of the actual job, and you watch how they do it. That fidelity is why it sits near the top of every ranking of hiring methods — and why it pairs so well with a structured interview, which measures a different thing.
For years the headline number was validity 0.54, from the Schmidt & Hunter (1998) meta-analysis, which made work samples look like the single best predictor of job performance. That number got revised. In 2022, Sackett and colleagues showed the older estimates were inflated by an overcorrection for range restriction, and recomputed the table: structured interviews came out highest at 0.42, with work sample tests at 0.33 — still top-tier, alongside job knowledge tests and biodata. The practical takeaway didn’t change much. Work sample tests remain one of the strongest tools you have, and the best pipeline runs a structured interview and a work sample test together.
The problem is that most companies design work sample tests badly. They set abstract tasks, evaluate on gut feel, and burn a candidate’s time on work unrelated to the role. This article is a step-by-step framework: how to design test assignments, build rubrics for objective evaluation, and use AI to generate role-specific tests.
What Makes a Work Sample Test Effective
An effective test assignment meets three criteria.
Fidelity. The assignment models a real task the person will actually do in the role. Not a whiteboard algorithm. Not a puzzle. A concrete work scenario from the first 90 days. Fidelity is the whole point — it’s what a work sample measures that an interview can’t.
Standardization. All candidates get the same assignment, the same resources, the same time. Evaluation follows a predetermined rubric — not the interviewer’s instinct.
Limited scope. The assignment takes 2–4 hours, no more. Anything requiring a full workday is free labor, not an assessment. Employed candidates simply won’t participate, and the company loses its best prospects.
There’s a fourth factor that rarely gets mentioned: the assignment should be genuinely interesting to the candidate. A good work sample test works both ways. The candidate sees what kind of problems they’ll tackle in the role. If the assignment is dull or pointless, strong candidates will draw their own conclusions about the company.
Anatomy of a Work Sample Test: 6 Components
Six elements. Every test assignment has them.
1. Role Context
A description of the company, product, and team. The candidate gets the same information a new hire would have on day one. Without context, the assignment turns into an academic exercise.
Example: “You are a product manager at a B2B SaaS company (ARR $5M, 2,000 customers). The product is a document workflow automation platform. Team: 4 developers, 1 designer, 1 QA.”
2. Task
A specific assignment drawn from real work. One task. Not three “to choose from” — that muddies the evaluation. Complex enough to reveal how the person thinks, focused enough to finish within the time limit.
3. Input Materials
The materials the candidate works with: data, documents, mockups, logs, metrics. These make the assignment concrete. Without them, candidates spend their time inventing context instead of showing what they can do.
4. Deliverable
Exactly what the candidate needs to submit. Format, structure, length. “Write a document” is poor. “Write a 1–2 page PRD including user stories, acceptance criteria, and success metrics” is good.
5. Constraints
Time, tools, available resources. Constraints level the playing field and reveal the ability to work within boundaries. Is using AI tools allowed? If so, state it explicitly.
6. Evaluation Rubric
Criteria and scoring scale. Without a rubric, two interviewers will score the same work differently. A rubric converts “I liked it / I didn’t” into something measurable.
How to Build a Rubric for Objective Evaluation
The rubric is what separates a work sample test from a gut-feel interview. Without it, the assignment is just another subjective judgment.
Rubric structure:
| Criterion | Weight | 1 (Below expectations) | 3 (Meets expectations) | 5 (Exceeds expectations) |
|---|---|---|---|---|
| Criterion A | 30% | Description | Description | Description |
| Criterion B | 25% | Description | Description | Description |
| Criterion C | 25% | Description | Description | Description |
| Criterion D | 20% | Description | Description | Description |
Rubric design rules:
4–6 criteria. Fewer isn’t granular enough. More and interviewers start skipping items or giving the same score across the board.
Weight coefficients. Not all criteria matter equally. For a developer, code correctness outweighs presentation. For a marketer, clarity of message outweighs visual execution.
Behavioral anchors. Each level describes specific behavior, not an abstract quality. Not “good understanding of the problem” — but “identified the root cause, proposed a solution that accounts for constraints, articulated trade-offs.”
Calibration. Before launching a hiring cycle, two team members independently score the same sample work. A gap of more than 1 point on any criterion means that level description isn’t concrete enough.
AI Prompt for Generating a Work Sample Test for a Role
Instead of designing assignments from scratch, use AI to generate a first draft. The prompt below produces a complete work sample test across all six components.
Role: You are an expert in organizational psychology and personnel assessment.
Task: Create a work sample test for the position of [ROLE NAME].
Company context:
- Product: [description]
- Stage: [seed / Series A / growth]
- Team size: [number]
- Key responsibilities in the first 90 days: [list 3–5 tasks]
Assignment requirements:
1. The assignment should model a real task from the first 90 days
2. Completion time: 2–4 hours
3. One clear deliverable with a specific format
4. Input materials: provide realistic (but fictional) data,
documents, or scenarios for the candidate to work with
Response format:
- Role context (2–3 sentences)
- Task (1 paragraph)
- Input materials (specific materials)
- Deliverable (format + length)
- Constraints (time, tools)
- Evaluation rubric (table: 4–6 criteria × 3 levels, with weights)
Additional requirements:
- The assignment must not require proprietary knowledge about the company
- The candidate must be able to complete it without additional questions
- Rubric should contain behavioral anchors, not abstract descriptions
This prompt works with any LLM. What you get is a draft — the team still needs to adapt it. Don’t use it as-is: AI doesn’t know the specifics of your company.
Example 1: Backend Developer
Context. Fintech startup, Series A. Product — a payment gateway for small businesses. Team: 6 developers, Go + PostgreSQL, microservices architecture.
Task. Design and implement an API endpoint for creating and processing payment refunds. The endpoint receives a transaction ID and refund amount (full or partial), validates the request, creates a refund record, and updates the merchant’s balance.
Input materials.
- Description of the existing database schema (tables: transactions, merchants, balances)
- OpenAPI specification for the current API (3 existing endpoints)
- List of business rules: maximum refund window of 180 days, amount cannot exceed the original transaction, one refund per transaction in the current version
Deliverable. Pull request to the provided repository with a template project: endpoint code, database migration, tests, brief description in the PR description (architectural decisions, trade-offs).
Constraints. 3 hours. Go (or language of choice if not Go). Any open-source libraries. AI tools permitted.
Rubric.
| Criterion | Weight | 1 | 3 | 5 |
|---|---|---|---|---|
| Business logic correctness | 30% | Edge cases missed (negative amount, expired refund) | Core business rules implemented, 1–2 edge cases missed | All business rules + edge cases + race conditions handled |
| API design | 25% | Non-standard response codes, missing input validation | RESTful, correct HTTP codes, basic validation | Idempotency, versioning, documented errors, pagination-ready |
| Code quality | 25% | No structure, magic numbers, duplication | Readable code, reasonable structure, naming follows conventions | Clean layer separation, dependency injection, configurability |
| Tests | 20% | No tests or only trivial cases tested | Unit tests for core logic, happy path + 1–2 error scenarios | Unit + integration, mocks for external dependencies, table-driven tests |
Example 2: Product Manager
Context. B2B project management SaaS, growth stage. 15,000 active teams, NPS 42. Core metric — weekly active teams. Product team: 3 PMs, each owning a separate area.
Task. Analyze churn data and write a PRD for a feature that will reduce churn in the 5–15-person team segment.
Input materials.
- 6-month cohort analysis (table: cohort, size, retention W1–W12)
- 10 exit interview excerpts (anonymized quotes)
- Current feature usage report (top 20 features by DAU, segmented by team size)
- Product pricing page
Deliverable. PRD, 2–3 pages: problem statement (with data), proposed solution, user stories (3–5), acceptance criteria, success metrics, risks.
Constraints. 4 hours. Google Docs or Notion. AI tools permitted for data analysis, but conclusions must be grounded in the provided data.
Rubric.
| Criterion | Weight | 1 | 3 | 5 |
|---|---|---|---|---|
| Data analysis | 30% | Conclusions not backed by data, summary without interpretation | Correct interpretation of key trends, conclusions tied to data | Finds non-obvious patterns, combines quantitative and qualitative data, identifies segments |
| Solution quality | 25% | Solution unrelated to the identified problem or too abstract | Solution addresses the problem, is implementable, accounts for constraints | Solution precisely targets root cause, considers alternatives, trade-offs are articulated |
| User stories and AC | 25% | No acceptance criteria or they’re immeasurable | 3–5 user stories with AC, covering the main flow | Stories cover edge cases, AC are specific and testable, prioritization is justified |
| Metrics and risks | 20% | Metrics absent or unrelated to the goal | 2–3 metrics, leading + lagging, tied to churn | Metrics with target values, measurement plan described, risks with mitigations |
Example 3: Growth Marketer
Context. D2C brand, product — coffee subscription. 8,000 active subscribers, CAC $38, LTV $142. Primary acquisition channel — Instagram (62%). Goal — channel diversification.
Task. Develop a strategy for launching a new acquisition channel that delivers 500 new subscribers in 90 days with a CAC no higher than $45.
Input materials.
- 6-month marketing dashboard (channels, spend, conversions, CAC by channel)
- Audience profile (demographics, interests, NPS comments)
- 3 examples of current ad creatives with metrics (CTR, conversion)
- Experiment budget: $5,000/month
Deliverable. Document, 2–3 pages: channel selection with justification, 90-day media plan (budget by week), 3 hypotheses to test, KPIs for each phase, creative examples (descriptions, not designs).
Constraints. 3 hours. Any document format. AI tools permitted.
Rubric.
| Criterion | Weight | 1 | 3 | 5 |
|---|---|---|---|---|
| Channel selection | 25% | Channel chosen without data analysis or doesn’t match the audience | Choice backed by audience and budget data, 1–2 alternatives considered | Deep channel-audience fit analysis, unit economics modeled, selection supported by benchmarks |
| Media plan | 25% | No phase breakdown or unrealistic budget | Phased approach, budget allocated logically, checkpoints included | Phases tied to hypotheses, budget optimized for testing, go/no-go criteria included |
| Hypotheses and KPIs | 25% | Vague hypotheses, KPIs unrelated to goals | 3 testable hypotheses, KPIs at each stage, connected to the end metric | Hypotheses prioritized by impact/effort, KPIs with target values, iteration process described |
| Creative strategy | 25% | Creatives unrelated to audience or channel | Creatives match brand tone, adapted for the channel | Creatives targeting specific segments, A/B variants, messaging framework included |
Example 4: Data Analyst
Context. E-commerce platform, 50,000 orders per month. Analytics team: 3 people. Stack: PostgreSQL, dbt, Metabase. The business is preparing to launch a loyalty program.
Task. Analyze the provided dataset and prepare recommendations for customer segmentation for the loyalty program.
Input materials.
- CSV file: 10,000 rows (customer_id, order_date, order_value, product_category, channel, city, is_returned)
- Description of the planned loyalty tiers (Bronze/Silver/Gold) with no defined thresholds
- Current business metrics: average order value $47, purchase frequency 2.3 times per year, retention rate 34%
Deliverable. Jupyter notebook or SQL + 1–2 page document: RFM analysis, proposed tier thresholds (with justification), 3 key insights, visualizations.
Constraints. 3 hours. Python or SQL. Any open-source libraries. AI tools permitted for code, but data interpretation must be the candidate’s own.
Rubric.
| Criterion | Weight | 1 | 3 | 5 |
|---|---|---|---|---|
| Analysis quality | 30% | Superficial descriptive statistics with no segmentation | Correct RFM analysis, logical segmentation, basic distributions | RFM + additional dimensions, non-obvious patterns found, cohort analysis |
| Business recommendations | 30% | Recommendations not tied to data or not actionable | Thresholds backed by data, specific recommendations | Thresholds optimized for business metrics, impact calculated, risk scenarios described |
| Code and reproducibility | 20% | Code doesn’t run or no comments | Code works, structured, with comments | Clean pipeline, reusable functions, data validation, README |
| Visualizations | 20% | Charts unreadable or uninformative | 2–3 charts, labeled, correct chart type selection | Charts tell a story, annotations, segment comparisons, actionable |
Process for Implementing Work Sample Tests
Designing the assignment is half the work. The other half is the process.
Step 1. Identify the key role task. Take the job description. Pick one task the person will do most in the first 90 days. Not the hardest — the most frequent and important one.
Step 2. Build the assignment. Use the AI prompt above to generate a draft. Adapt it: swap the data for realistic examples, check the time constraints, make sure it’s solvable without internal knowledge.
Step 3. Run a pilot. Ask a current employee in the role to complete the assignment. Time them. Over 4 hours — cut scope. If the employee scores below 4 on the rubric — either the rubric’s wrong or the assignment’s too hard.
Step 4. Calibrate scoring. Two evaluators independently review the pilot work. A gap of more than 1 point on any criterion — rewrite that level description.
Step 5. Embed in the pipeline. The work sample test comes after initial screening (resume + brief call) and pairs with the final structured interview. Only candidates who’ve proven their skills reach the final round. The team’s time gets protected.
Step 6. Collect feedback. After each hiring cycle, ask new hires: how well did the assignment reflect the actual work? Adjust accordingly.
Automation Through SOP
A work sample test is part of the hiring process. To avoid rebuilding the assignment from scratch each cycle, document it as an SOP: the template, rubric, and process for sending and scoring. For how to build an SOP with AI, see the SOP Generator: automating process documentation.
Common Mistakes
Assignment unrelated to real work. Algorithm problems for a role that’s mostly CRUD APIs. Abstract case studies for a marketer who’ll be launching specific channels. Fidelity is the primary criterion: the assignment has to model reality.
No rubric — or one that’s too abstract. “Code quality: good / medium / poor” isn’t a rubric. That’s three words that everyone interprets differently. Behavioral anchors aren’t optional.
Too much scope. An 8-hour assignment is a negative signal. Strong candidates have multiple offers and limited time. 2–4 hours is the ceiling.
The same assignment for years. Assignments leak. Candidates share them in group chats. Update the data and context every 3–6 months. The structure can stay the same; the specifics should change.
No feedback to the candidate. They spent 3–4 hours. At minimum, explain why they didn’t move forward. Better yet, point to 2–3 specific rubric items. It’s a small investment in your employer brand.
Conclusion
Work sample tests are one of the most valid hiring tools available — and the most direct, since they measure the actual job skill rather than a proxy. The corrected 2022 data puts structured interviews narrowly on top, so the strongest move isn’t to pick one: run a structured interview and a work sample test together. Six components make a good test: context, task, input materials, deliverable, constraints, rubric. AI drafts the assignment in minutes. A pilot and calibration turn that draft into something that actually works. The four examples here cover development, product, marketing, and analytics. Adapt one to your role, run a pilot, and put it into your pipeline.
Need help designing hiring processes with AI-powered assessments? I help startups build AI products and automate processes — belov.works.