The Senior Engineer Trial Week: How We Replaced Our Technical Interview
We killed our four-stage technical interview and replaced it with a paid trial week. Here's exactly how it works, what it costs, and why our offer-acceptance rate nearly doubled.
We used to run a four-stage technical interview: recruiter screen, take-home, pairing session, system design. It took three weeks, bored good candidates, and still produced the occasional bad hire. Two years ago we scrapped it for a paid trial week — and we're not going back.
This is the playbook: how we structure it, what we pay, what we measure, and the failure modes we've seen.
Why the standard interview loop broke for us
We hire mid-to-senior engineers for client work — people who need to walk into a half-built Rails app or a React Native codebase in week two and ship. The traditional loop optimizes for the wrong signals.
Take-homes measure patience and free time, not judgment. Live coding measures composure under artificial stress. System design interviews reward people who've memorized the Designing Data-Intensive Applications table of contents. None of them tell you whether somebody can read 40,000 lines of someone else's TypeScript on a Monday and open a sensible PR on Thursday.
And the loop was leaky at the top of the funnel. The engineers we most wanted — the ones already shipping at other good shops — would often ghost after the take-home. Their time is worth money. We weren't offering any.
The structure of a trial week
A trial week at our shop is five business days of paid, part-time work on a real but non-critical codebase. The candidate keeps their day job. We're buying evenings and a weekend, roughly 12 – 18 hours of focused effort, and we pay for every one of them.
Here's the shape:
- Day 0 (Friday): 45-minute kickoff call. We hand over repo access, a Loom walkthrough of the codebase, and a written brief.
- Days 1 – 4: Candidate works async. One of our engineers is on Slack for questions, with a two-hour response SLA during business hours.
- Day 3 (Wednesday): 30-minute mid-week check-in. Mostly to unblock, not to grade.
- Day 5 (Friday): 60-minute wrap. Candidate demos what they built, we discuss trade-offs, and we do a short retro on the week itself.
The brief is deliberately underspecified. We want to see what they ask, what they assume, and what they ship when the requirements are fuzzy — because that is the actual job.
What the brief looks like
We keep a small internal tool with real complexity for this purpose. The brief is one page. Example:
We want to add a bulk-import feature for team members from a CSV. It should validate rows, show a preview, and let the user fix errors inline before committing. Edge cases are your call. Scope it to what you can genuinely finish and polish in roughly 15 hours.
No acceptance criteria beyond that. The candidate decides what "done" means, and defending that decision is half the signal.
What we pay and why
We pay a flat rate per trial, not hourly, because hourly invites gaming on both sides. The rate is pegged to roughly two days of what we'd bill the candidate's seniority to a client. In 2026 that lands somewhere between $1,500 and $3,000 depending on role and region. We pay on completion regardless of outcome, including if we decide not to extend an offer.
The economics work because:
- A bad senior hire costs us 3 – 6 months of salary, lost client trust, and a team morale tax that doesn't show up on any P&L. One avoided mishire pays for a year of trials.
- Our take-home acceptance rate used to hover around 55%. Trial-week acceptance is comfortably above 85% in our experience. We're paying to see more candidates finish.
- Offer-acceptance after trial is also higher. By Friday both sides have strong information. Negotiation is short.
What we actually evaluate
We stopped scoring code quality on a rubric. Everyone writes decent code in a week with no deadline pressure. The signal is elsewhere.
The four things we grade
- Question quality. What did they ask in the first 48 hours? Senior engineers surface ambiguity early. Juniors (and surprisingly many "seniors") start coding and discover problems at hour 10.
- Scope decisions. Did they cut the right things? A candidate who ships a working import without inline editing but with excellent error messages is often better than one who built everything and polished nothing.
- PR hygiene. Commit history, PR description, how they responded to review comments on Day 4. This is a near-perfect proxy for what working with them will feel like.
- The Friday retro. We ask: what would you do differently with another week? What did the brief miss? Weak candidates say "nothing, it was great." Strong ones have a list.
We write a one-page memo per candidate using those four headings. No numeric scores. The hiring manager and one engineer who touched the PR both sign off.
# Trial Memo — [Candidate]
## Question quality
- Asked about auth model on Day 1 (good)
- Didn't clarify CSV size assumptions until Day 3 (ok)
## Scope decisions
- Dropped inline editing, built a re-upload flow instead
- Reasonable call given time; discussed trade-off unprompted
## PR hygiene
- 6 commits, each with a clear message
- Responded to 4/5 review comments; pushed back on one with good reasoning
## Friday retro
- Flagged that the brief didn't define duplicate-row behavior
- Would add telemetry next; didn't want to touch infra without asking
## Recommendation
Offer. Strong fit for client work.
Failure modes we've hit
This isn't a silver bullet. Things that have gone wrong:
Candidates who can't do evenings. Parents, people with second jobs, folks in time zones where our Slack hours are 2am. We now offer a flexible variant: two full consecutive days off work (we cover the lost income if they can document it) instead of a spread week. Takes more coordination but widens the pool. If you're hiring internationally, build this in from day one — see our notes on distributed team setup for related process.
Our engineers playing favorites. The Slack-on-call engineer bonds with the candidate over four days and becomes an advocate regardless of output. We now rotate the on-call engineer mid-week and require the memo to be co-signed by someone who didn't chat with the candidate directly.
Scope-creeping the brief. Early on we kept adding "little extras" to make it more realistic. The trial ballooned to 25+ hours and candidates burned out. The brief is now locked and we review it quarterly, not per-candidate.
Confusing trial with contract-to-hire. A trial week is an interview we pay for. It is not a 90-day contract. If you blur the line, candidates (correctly) start negotiating like contractors and your legal exposure grows. Keep it short, keep it bounded, keep the paperwork clean.
When not to use a trial week
We still run traditional interviews for a few cases:
- Staff+ roles where the job is mostly judgment, mentorship, and architectural calls. A week isn't enough to see that. We use longer paid consulting engagements instead — two or three real advisory sessions on a live problem.
- Candidates from direct referrals who come with a strong signal from someone we trust and a public body of work. We'll still do a technical conversation but skip the trial. Life's too short.
- Very junior hires where the point is potential, not current output. Trial weeks punish inexperience in ways that aren't predictive.
For the broad middle — the mid and senior ICs who make up most of an agency's hiring — the trial is now our default. If you want to see how this fits into our broader team model, we've written about it in the context of our engineering services.
Where we'd start
If you're going to try this, don't rebuild your whole loop on Monday. Pick your next senior hire and run one trial in parallel with your existing process. Compare the memos to your interview notes two weeks later. You'll know within three candidates whether the signal is better.
Budget for the trials up front — put a line item in your hiring plan so recruiters don't treat it as a favor. Write the brief this week, before you need it, using a real feature you've been putting off. And decide now who co-signs the memo, because the day you want to hand-wave past that rule is the day you make a mistake you'll regret for six months.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Killing the Discovery Phase: Why We Replaced It With a Paid Architecture Sprint
Discovery phases rot. They produce PDFs nobody reads and estimates nobody trusts. Here's the paid architecture sprint we run instead, and why clients actually pay for it twice as often.
The Statement of Work Is a Product: How We Rewrote Ours After Losing Three Fixed Bids in a Row
An SOW isn't paperwork. It's the first thing your client reads in anger when a project goes sideways. Here's how we rebuilt ours to actually protect both sides.
The Equity Deal That Almost Sank Us: A Framework for Agencies Taking Stock Instead of Cash
Taking equity from a client sounds like free lottery tickets. It isn't. Here's the framework we use to decide when stock beats a wire transfer — and when it's just a discount with extra paperwork.
