Hiring developers is often presented as a question of evaluation.
How good is the coding challenge?
Are the interview questions sharp enough?
Does the culture interview really catch red flags?
After hiring many developers, I’ve learned something different:
Evaluation is not the hard part.
Operations are.
What breaks hiring processes at scale is rarely judgment.
It’s friction.
And friction quietly eats time, attention, and energy.
This is a reflection on how I run our hiring pipeline and how a small, unsexy system removed more pain than any interview framework ever did.
The hiring process we use at Relai
For developer roles (mobile, front-end, back-end), our process is deliberately simple and consistent:
- Our HR screens CVs
- First quick call with HR
- A short culture call with me
- A coding challenge (using codility)
- A technical interview with the tech lead and the team
- A final call with our CEO
This process works well.
We’ve iterated on it, and the signal is good.
But when you run this flow for hundreds of candidates, something else emerges.
The structure isn’t the bottleneck.
Running it smoothly is.
Where things start to break
Hiring doesn’t fail loudly.
It degrades quietly.
A delayed email here.
A slightly unclear instruction there.
A candidate who shows up unprepared not because they’re bad, but because expectations weren’t crystal clear…
Most of the friction lives in places people rarely talk about:
- coordination
- scheduling
- repetitive communication
- small wording differences that create big misunderstandings
And nowhere was this more obvious than in the technical interview invitation.
The hardest email to send: the technical interview invitation
The technical interview is the most fragile step in our process.
It involves:
- multiple engineers
- a senior candidate
- a precise agenda
- and very little room for ambiguity
If this email is unclear, the interview suffers before it even starts.
This is the email I send candidates at that stage (simplified):
Hi $candidate_name,
Thanks for your answer! I just sent you a calendar invite.
We would like to invite you for the 2nd round of interview with 2 of my back-end developers for a 1 hour call, roughly split as follows:
– 20 minutes: presentation from you about a project you worked on and are excited to share (learnings, failures, successes). You can use any material you want (slides, PDF…).
– 10 minutes: questions from the Relai team about that project.
– 30 minutes: discussion with the Relai team about various Golang topics and the coding challenge.Looking forward to it
It looks simple.
It isn’t.
Each line matters:
- the agenda sets expectations,
- the time split reassures the candidate,
- the presentation framing signals what kind of engineer we value,
- mentioning the coding challenge avoids surprises.
Now imagine writing this correctly hundreds of times, across roles, teams, and time zones.
Why “just having templates” wasn’t enough
Like most people, I tried the obvious solutions first:
- old sent emails,
- drafts in Gmail,
- snippets in Notion,
- copy-paste from previous candidates.
All of them failed in the same way.
They added friction at the moment of use.
I had to:
- search for the right version,
- context-switch,
- re-read everything to make sure nothing was missing,
- slightly rewrite things “just this once”
Individually, these are tiny costs.
Collectively, they create fatigue.
And hiring is already a decision-heavy activity.
Anything that drains attention makes judgment worse.
Turning a fragile email into a system
At some point, I stopped treating this as “just an email”.
I treated it as a system.
I broke it down into:
- a fixed structure (agenda, tone, expectations),
- a few variables (candidate name, role, date, tech stack),
- and a way to insert it instantly, wherever I was working.
That’s why I use ClipDeck.
Not because I needed templates.
But because I needed zero friction.
When the snippet is one shortcut away:
- the wording stays consistent,
- nothing important gets dropped,
- and my brain stays focused on evaluating the candidate, not rewriting logistics.
The unexpected benefit: better interviews
Once this email became consistent, something interesting happened.
Candidates showed up better prepared.
Interviews felt calmer and more focused.
Engineers knew exactly what to expect.
Follow-up questions dropped significantly.
We didn’t change the interview itself.
We removed ambiguity before it started.
That’s a pattern I’ve seen again and again: small operational systems often unlock more leverage than big conceptual changes.
A broader lesson
Hiring is ultimately about judgment.
But judgment requires:
- clarity,
- energy,
- and mental space.
Every repetitive task that steals attention makes judgment worse.
Over time, I’ve learned to be ruthless about these small frictions.
Not because they’re exciting but because they compound.
ClipDeck started as a tool I built for myself to reduce that friction.
It quietly sits in the background, doing the boring work consistently.
And that’s exactly what good systems should do.