This week’s newsletter is sponsored by Blitzy.

Blitzy is the first autonomous software development platform with infinite code context, enabling Fortune 500 companies to ship 5x faster from Figma design to production code.

It’s engineered specifically for enterprise-scale codebases due to its deep understanding of your codebase and design standards. This can clear years of tech debt, execute large-scale refactors, or deliver new features quickly.

Some of Blitzy’s core features:

• Self-improving knowledge graph: Maps millions of lines of code and their dependencies to create a live understanding of your codebase.

• Figma integration: Turns Figma designs into responsive, pixel-perfect frontend code that connects to your backend.3

• Agent orchestration: 3,000+ specialized agents plan, build, and validate production-ready code.

Result: 80% of the work delivered autonomously, 5× faster. If you are working on an enterprise-scale codebase, I’d definitely recommend checking them out!

Sign up for free and start building

Thanks to Blitzy for sponsoring this newsletter. Let’s get back to this week’s thought!

Intro

A lot of companies mimic what big companies do, especially Big Tech companies like Amazon, Microsoft, and Google.

This includes hiring. A lot of startup founders hire engineers the same way Big Tech does: long processes, technical interviews focused on algorithms, and system design discussions focused on big scale and high load.

But is this really the way to go? Based on the title, you’ve already got the idea that it’s not. Luckily for us, Neil Matthams, founder and global talent specialist at Functionn, will tell us exactly why that’s not the case.

Let’s introduce our guest author and get started.

Introducing Neil Matthams

Neil Matthams writes High-Signal Hiring, a weekly newsletter on hiring systems built on 500+ technical hires, across 30 countries for companies like Canva, UBS and Grab. He’s also the founder of Functionn, a boutique recruitment firm that partners with global startups to source engineering talent from emerging markets worldwide.

If you’re in charge of hiring for an early-stage startup and you’re not finding the right engineer for your company, the issue might be your hiring process. Today, Neil shares with us a common startup hiring problem and a solution designed to fit your needs.

Take it away, Neil!

The Engineer Who Aced Every Interview and Failed in 8 Weeks

I once helped a bootstrapped founder hire a FAANG back-end engineer. The engineer’s CV was flawless, the technical screen was impressive, and his references were strong. The founder was buzzing.

Within eight weeks, the situation was falling apart.

The engineer kept asking where the technical specs were. Who the owner of architecture decisions was. When the CI/CD pipeline would be “production grade.” He wanted to know the on-call rotation, the code review policy, and the sprint cadence.

None of it existed. That was the whole point of the hire.

The founder thought he was getting someone who could build. What he got was someone who could operate within a system that someone else had built. There’s a massive difference, and most founders learn about it the expensive way.

In my experience, a misaligned engineering hire at a startup costs three to six months of lost momentum. At the early stage, that can be the difference between shipping and dying.

I’ve spent over 20 years in recruitment and made over 500 technical hires across startups and scale-ups globally, and I can tell you that this pattern repeats constantly.

Founders and engineering leaders get excited about pedigree and then wonder why the hire doesn’t work. The answer is almost always the same: You evaluated for the wrong things.

This article breaks down why and what to do instead.

1. Builders vs. Operators

Scaled companies have a hiring problem that’s a luxury for startups: They have too many candidates and need to filter efficiently. Their interview processes are designed to reduce a large pool to a manageable shortlist using standardized, repeatable evaluations.

This makes sense at scale. When you’re hiring more than 100 engineers a year, you need scorecards, structured panels, leveling rubrics, and calibration sessions. You need a system that produces consistent outcomes across dozens of hiring managers. Nothing wrong with that.

The issue is that this system is optimized to find specialists who can operate within an existing machine. In other words, people who work within defined boundaries, follow established patterns, and execute against clear requirements.

At an early-stage startup, there are no boundaries. No established patterns. The requirements change weekly. Sometimes daily.

Scaled companies test for depth in a single domain, but startups need breadth across many. They test for how someone operates within a process, but startups need someone who can create the process from nothing. And they evaluate collaboration within large, cross-functional teams, but startups need someone who can just get it done, often alone and often wearing three hats at once.

The traits that make someone a top performer at an established company (deep specialization, comfort with process, ability to navigate organizational complexity) are frequently the exact traits that make someone struggle in an early-stage environment.

This doesn’t mean FAANG engineers are bad engineers. Far from it. It means the evaluation system that identified them as strong is measuring something completely different from what your startup needs.

The expectation gap is where it breaks

The ex-FAANG hire I mentioned earlier wasn’t incompetent. He was genuinely talented. But most of his career had been spent in environments where infrastructure, tooling, documentation, and process were givens. He’d never built any of that himself because he’d never had to.

When he joined a six-person startup and realized there was no staging environment, no API documentation, no proper error monitoring, and no product manager writing specs, he didn’t adapt. Instead, he froze. Not because he lacked ability, but because his entire frame of reference for “how engineering works” didn’t match the startup’s reality.

And honestly, both sides got it wrong. The founder assumed pedigree meant adaptability. The engineer assumed a startup meant a smaller team but the same infrastructure. Nobody pressure-tested those assumptions during the interview. That was the real failure.

2. Most Founders Copy Big-Tech Loops and Select for the Wrong Things

I see this constantly. A hiring manager reads a blog post about how Google runs its hiring process. They see structured scorecards, panel debriefs, system design rounds, algo-tests and take-home projects. They think, “This looks professional. I should do something similar.”

So they build a mini version of that process. It sounds reasonable.

It’s actually a trap.

Why these processes break down at startups

Algorithm screens don’t predict startup performance. When your startup needs someone to ship a working MVP in three weeks, knowing whether they can implement a balanced binary search tree on a whiteboard is irrelevant. What matters is whether they can make pragmatic technology choices under time pressure with incomplete information. No algorithm screen tests for that.

System design rounds test the wrong kind of design. Enterprise system design questions assume scale: millions of users, distributed systems, eventual consistency. Early-stage startups don’t have that problem. You need someone who can design something simple that works now and won’t collapse when you need to change direction next month. Designing for premature scale is a red flag at an early-stage startup, one I’ve seen countless times.

Panel debriefs introduce noise, not signal. Debrief meetings seem like a responsible thing to do. They’re not. They only exist because the interview failed to produce a clear signal in the first place.

Think about the last debrief you sat in. Opinions were shared instead of observations, right? Memory replaced evidence. The loudest voice set the tone. By the end, the group felt aligned, didn’t it? But alignment is not necessarily clarity. It’s often just conformity.

There’s also a decay problem. Every minute spent discussing a candidate after the interview introduces distortion. What the candidate actually said matters less than how it’s retold. Social bias creeps in. People anchor on each other’s reactions instead of on the work. This is how hiring becomes political without anyone intending it to.

If your interview is designed around a specific, testable question (Can this person independently own this problem in 90 days?), the output should be a simple yes or no. No meeting required.

And if you do need multiple people involved, follow one simple rule: If feedback isn’t written down immediately after the interview, it doesn’t count. Written feedback forces precision, preserves first impressions, prevents groupthink, and exposes disagreement early. If two interviewers disagree, that’s not a problem to be smoothed over in a room. It’s a sign that the interview itself needs to be redesigned.

Take-home projects test compliance, not capability. Long take-home assignments favor candidates with free time and the patience for unpaid labor. They filter out experienced engineers who have options and don’t need to prove themselves through busywork. The best engineers I’ve worked with will push back on a six-hour take-home project. That pushback is a good signal: It shows they value their time and have standards.

What founders end up selecting for

When you run a Big Tech interview loop at a startup, you end up selecting people who are good at Big Tech interviews. These are people who are comfortable with structured evaluation, who articulate well in formal settings but may not perform in chaos, who have deep knowledge in specific technical areas but struggle outside their domain.

People expect a role to look like what the interview suggested. If it suggests a structured, well-defined, and resourced role, that’s what they’ll expect. This is the killer. The interview becomes an implicit promise about what the job will be like. If your interview feels like Google’s, the candidate assumes the job will feel like Google’s. When it doesn’t, you’ve got a misalignment that no onboarding plan can fix.

3. The Traits That Predict Early-Stage Success and How to Test for Them

After years of placing engineers in startups and watching which hires thrive and which don’t, I can tell you the traits that matter. And none of them show up on a typical scorecard.

Comfort with ambiguity

This is the single biggest predictor of startup success in my experience. Can this person function, and actually enjoy functioning, when the requirements are vague, the priorities shift, and nobody has the answer?

Most engineers coming from structured environments are used to clear tickets, defined acceptance criteria, and someone else making product decisions. At an early-stage startup, the engineer is making those decisions. Every day.

How to test for it: Don't describe the role in perfect detail during the interview. Instead, lay out your 90-day mission (aka your priorities for the first 3 months) and ask, "What risks do you see? What information would you need before starting? What would you do first?" Listen for how they handle the gaps. Do they ask clarifying questions and propose approaches, or do they wait for you to fill in the blanks?

Low ego and willingness to do nonengineering work

Startups need engineers who will do whatever needs doing. That includes writing docs, talking to customers, debugging a CSS issue even though they’re a back-end engineer, setting up the billing integration, and sometimes just answering support emails.

Engineers with big egos (often correlated with Big Tech pedigrees) will resist work they consider beneath them. At a startup, nothing is beneath anyone. If the toilet is broken and you’re the one in the office, you fix the toilet.

At a startup, the line between engineering and everything else is blurry. Your first engineers will need to contribute to product decisions, customer calls, hiring conversations, investor updates, and operational firefighting. The best early-stage engineers I’ve seen think of themselves as builders first and engineers second. They care about the outcome more than their job title.

How to test for it: Ask about a time they did work that was outside their job description. Make this a conversation: Ask detailed follow-up questions. Listen for enthusiasm or resentment. The right candidate will light up when talking about wearing multiple hats. The wrong one will frame it as something they “had” to do. You can also just be up front about what the role involves. Tell them, “In any given week, you might ship code, hop on a customer call, help draft a product spec, and review a hire. How does that sound?” Their reaction will tell you everything.

Speed over perfection

This one is nuanced. You don’t want someone who ships garbage. But you absolutely need someone whose instinct is to get something working and iterate rather than spend two weeks architecting the “right” solution.

Established companies reward thoroughness and rigor; startups reward speed and learning. These are fundamentally different value systems. Switching between them is harder than most people think.

How to test for it: Skip the whiteboard exercise, and give candidates a real problem from your product. Ask them to walk you through how they’d approach solving it. Listen for time awareness. Are they thinking about what can ship this week or what the ideal architecture looks like? Both have merit, but at an early-stage startup, you need the first one.

Self-direction

This one is simple but critical. Can the candidate figure out what to do next without being told? At a large company, there’s always a manager, a project manager, or a sprint board telling you the priority. At a startup, especially in the first 10 hires, there often isn’t.

How to test for it: Ask them to describe a project they initiated themselves. Not one they were assigned but something they saw as a problem, decided it mattered, and did something about it. If they can’t give you a clear answer, that’s a red flag.

What to Do Instead: A Practical Framework

I’m not saying you should throw away all structure. Structure matters. But it needs to be the right structure for the stage you’re at.

I’ve seen a three-step loop work across multiple startups and markets worldwide. You can run it in a single session or split it across two focused conversations. How long you spend on each step is up to you. You could theoretically spend two hours on step 2 alone if the problem warrants it. The length isn’t really the point. What matters is what you’re evaluating for. Either way, it produces far more signal than a multiround process.

Step 1: Mission → sign

Share your 90-day mission with the candidate. Not a job description but your actual priorities for the first 90 days of the hire. It should include one clear outcome the engineer must deliver, why it matters right now, and what constraints they’re operating within. And it should be three sentences, max. If you can’t write it in 10 minutes, the role isn’t ready (I wrote about this in more detail in this newsletter).

Then ask the candidate:

• What stands out to you about this mission?

• What risks do you see over these 90 days?

• What information would you need before starting?

You’ll learn instantly whether they think clearly, whether they get what matters and whether they can engage with ambiguity.

Step 2: Depth → thinking

Choose one real problem from your 90-day mission and go deep. You’re evaluating:

• How they break problems apart

• How they choose trade-offs

• How they simplify complexity

• How they explain decisions

• How they orchestrate agents

This is a real conversation about a real problem. You’ll learn far more about how this person thinks than you would from any traditional algo question or coding test.

Step 3: Alignment → fit

This is the part most people skip. And it’s the part that determines whether the hire works.

Discuss:

• Why move now? Why choose an early-stage startup?

• How they like to work

• How they make decisions

• What they expect from a founder

• How they handle ambiguity

• What great collaboration looks like to them

You’re not evaluating culture fit (a vague, mostly useless concept). You’re evaluating compatibility and expectations. Will this person thrive in your specific environment?

Why this works better

This loop does three things that Big Tech processes don’t.

It reveals how someone thinks, not what they know. Knowledge is easy to acquire; thinking patterns are not. An engineer who can break down your specific problem and reason through trade-offs is clearly worth more than one who has memorized system design patterns.

It reveals misalignment before the hire. The alignment conversation forces both sides to be honest about expectations. If the candidate wants clear requirements and weekly 1:1 meetings and you’re a founder who communicates through Slack messages at midnight, better to find that out now.

It treats the candidate like a human being. The best engineers have options. They’re not desperate. When you share your real mission and problems and have a real conversation, you’re signaling that you respect their time and judgment. That matters more than most hiring teams realize.

Conclusion

Early-stage hiring is a completely different discipline from scaled-company hiring. It requires different traits, different evaluation methods, and a different mindset about what “good” looks like.

A FAANG background doesn’t make someone a bad hire. But a FAANG-style interview process will almost certainly lead you to the wrong hire. You’ll select people who excel in structure and then drop them into an environment with none.

You don’t need to lower your bar. You need to change what the bar measures. Test for how someone thinks, how they handle ambiguity, and whether their expectations match your reality. That matters far more than what’s on their CV.

Last Words

Special thanks to Neil for sharing his insights with us! Be sure to check him out on LinkedIn and check out his weekly newsletter, High-Signal Hiring.

Liked this article? Make sure to 💙 click the like button.

Feedback or addition? Make sure to 💬 comment.

Know someone that would find this helpful? Make sure to 🔁 share this post.

Whenever you are ready, here is how I can help you further

• Join the Cohort course Senior Engineer to Lead: Grow and thrive in the role here.

• Interested in sponsoring this newsletter? Check the sponsorship options here.

• Take a look at the cool swag in the Engineering Leadership Store here.

• Want to work with me? You can see all the options here.

Get in touch

You can find me on LinkedIn, X, YouTube, Bluesky, Instagram or Threads.

If you wish to make a request on particular topic you would like to read, you can send me an email to info@gregorojstersek.com.

This newsletter is funded by paid subscriptions from readers like yourself.

If you aren’t already, consider becoming a paid subscriber to receive the full experience!

Check the benefits of the paid plan

You are more than welcome to find whatever interests you here and try it out in your particular case. Let me know how it went! Topics are normally about all things engineering related, leadership, management, developing scalable products, building teams etc.