Types of Tech Interviews: The Complete 2026 Taxonomy for Software Engineers
If you have been in the job market for more than a month, you have already noticed something strange. Two companies hiring for the same "Senior Backend Engineer" title will run completely different gauntlets. One asks you to whiteboard a graph problem in forty-five minutes. The other hands you a GitHub repo and says "see you in a week." A third does neither and spends ninety minutes asking about a conflict you had in 2019.
None of them are wrong. They are measuring different things, and each interview type has a name, a history, and a known failure mode. Knowing which stage you are walking into is the difference between preparation and panic. This guide breaks down every interview format you will meet in 2026, what each one is actually measuring, and which companies still use it seriously versus which have quietly retired it.
Table of Contents
- Why the Interview Stack Keeps Changing
- Phone Screens: The Gatekeeper
- Online Assessments (OAs) and Take-Home Screens
- The Coding Interview
- System Design Interviews
- Behavioral Interviews
- The Bar Raiser Round
- Hiring Manager Rounds
- Skip-Level Interviews
- Take-Home Projects
- Pair Programming and Collaborative Rounds
- Company Playbooks: Who Uses What
- Sequencing: How the Rounds Stack
- Frequently Asked Questions
- Conclusion
Why the Interview Stack Keeps Changing
Three forces reshaped tech hiring in the last eighteen months. The first is AI-assisted coding, which broke the assumption that a candidate writing clean code on a blank screen is a reliable signal. The second is remote-first hiring at scale, which made proctored assessments and live video the default rather than the exception. The third is the tightening labor market, which pushed companies to run more rounds, not fewer, because the cost of a bad hire went up.
The result is a messier, longer funnel. Where a 2019 process had three or four rounds, a 2026 process has five or six, plus an async screen on the front. Understanding the shape of this funnel is the first step to preparing for it.
Phone Screens: The Gatekeeper
The phone screen (now almost always a video call despite the name) is the first human touchpoint. It is usually thirty minutes, sometimes forty-five, and it is run by either a recruiter or a working engineer.
A recruiter phone screen is not technical. It checks that you are real, that you are interested, that your compensation expectations are in range, and that your background matches the JD. It is a pass/fail conversation and most candidates pass if they show up prepared and do not lowball their base expectations in the first five minutes.
An engineer phone screen is the first technical gate. Expect a warmup problem (reverse a string, build a frequency counter), one medium-difficulty coding problem, and a few minutes of questions at the end. The signal being measured is "can this person code at all and talk about it while coding." Failure modes are silence, getting stuck on syntax, and writing code without explaining the approach.
Preparation notes: have a clean setup, a quiet room, and your resume open in another tab. Practice narrating your thought process out loud while solving two or three easy problems the day before. Nothing kills a phone screen faster than a candidate who codes silently for eight minutes.
Online Assessments (OAs) and Take-Home Screens
The OA is an asynchronous coding test, usually delivered through HackerRank, CodeSignal, Codility, or an internal platform. Duration ranges from sixty minutes (for new grads) to four hours (for specialized roles). You get two to four problems, often with hidden test cases.
The OA is the highest-volume filter in the funnel. A company with ten thousand applications might let all of them attempt the OA, then interview only the top five percent. That scale is why the problems are often harder than what you will see later in the loop: the OA is not trying to evaluate you fairly, it is trying to rank you against a large pool.
The grading is almost always purely automated. Your code is judged by correctness against test cases, plus sometimes runtime and memory. You rarely get partial credit for "nearly working," which is a brutal surprise for candidates who are used to in-person interviewers granting pity points.
There is also a category of async screen that is not quite an OA: the take-home screen. This is shorter than a full project (two to four hours) but delivered at your own pace. It is common at startups that do not want to pay for HackerRank licenses.
The Coding Interview
The coding round is the archetype of the tech interview. Forty-five to sixty minutes, one or two problems, solved live while an interviewer watches. This is where you face the LeetCode canon: arrays, strings, hash tables, trees, graphs, dynamic programming, occasional tricky math.
Depending on the company, this round splits into sub-formats (covered in depth in our separate article on coding interview formats): live IDE, whiteboard, shared doc, CoderPad, debugging prompts. The core loop is the same: clarify the problem, describe an approach, code it, test it, talk about complexity.
The signal measured is not "did you solve it." The signal is your problem-solving process, the cleanliness of the code, your communication, and your ability to handle hints without ego. Many candidates solve the problem and still fail this round because they did it silently, guessed at edge cases, or dismissed the interviewer's nudge.
System Design Interviews
The system design round enters the loop at the senior level and becomes the most important round at staff and above. Duration is typically forty-five to sixty minutes and the prompt is vague on purpose: "design a URL shortener," "design the news feed," "design a rate limiter."
What is being measured here is your ability to take an ambiguous business problem, scope it into technical requirements, pick appropriate building blocks (databases, caches, queues, load balancers), reason about tradeoffs, and push back on your own assumptions when the interviewer stress-tests them.
There is no single right answer. Two candidates can give completely different designs and both pass, as long as each design is internally coherent and the candidate can defend the choices. Failure modes include jumping to implementation too fast, choosing tools by name without understanding the tradeoff, and freezing when the interviewer asks "what if the traffic goes ten times higher."
System design is the round where AI assistance is least useful in 2026. The prompts are open-ended enough that memorized answers are easy to spot, and interviewers increasingly use follow-up questions that force genuine reasoning.
Behavioral Interviews
The behavioral round asks you to describe past situations: a conflict, a failure, a project you owned, a decision you regret. Typical duration is forty-five to sixty minutes, often run by a manager or senior engineer.
Most candidates underprepare for this round because they think "I have stories, I will just talk." That does not work. The behavioral interview is evaluated against competency rubrics (ownership, scope, impact, collaboration, judgment) and the stories you choose either hit those rubrics or they do not.
Rigid STAR (Situation, Task, Action, Result) is still taught everywhere but does not survive at the staff level. Senior interviewers want to hear about ambiguity, tradeoffs, and what you would do differently. A separate article covers the frameworks that actually work at Staff+ (CAR, SOAR, PAR, FAR).
The Bar Raiser Round
Invented at Amazon but now adopted in various forms at other companies, the bar raiser is a round run by a trained senior employee from a different team than the one hiring. Their job is not to assess fit for the specific role. Their job is to check that this candidate would raise the average bar of engineers at the company.
The bar raiser has veto power. Even if every other interviewer votes hire, a bar raiser "no" can sink the loop. This is why the round tends to feel different: the interviewer is not trying to fill a headcount, they are trying to protect a standard.
Format is usually a mix of behavioral and scenario-based questions, often with deeper follow-ups than a normal behavioral round. At Amazon, the bar raiser heavily probes the Leadership Principles. At other companies it might focus on judgment calls, how you handle disagreement, or what your definition of "done" is.
Hiring Manager Rounds
The hiring manager round is the conversation with the person who will be your direct boss if you are hired. Duration is forty-five to sixty minutes. Format is a mix of behavioral, technical overview, and mutual-fit discussion.
This round is bidirectional in a way others are not. The manager is evaluating whether you can operate at the seniority advertised, whether you will cause them headaches, and whether the team will like working with you. You should be evaluating whether this person is someone you want to report to, how they run one-on-ones, and what the last two people on the team shipped.
Do not waste this round. Prepare specific, non-Glassdoor questions about the team's roadmap, last quarter's biggest lesson, and how the manager handles underperformance. The quality of your questions is itself a signal.
Skip-Level Interviews
The skip-level is a conversation with your potential boss's boss. It is most common at senior, staff, and principal levels, and at executive-heavy companies. Expect thirty to forty-five minutes.
This round is less about technical skills and more about organizational fit, leadership potential, and strategic thinking. Skip-level interviewers are checking whether you can operate above the role if needed, whether you understand business context, and whether you would be a credible partner at the leadership table.
Common questions: tell me about a time you influenced across orgs; what would you change about your last company if you had the power; what do you think our biggest technical risk is. The last one is a trap if you have not done your research.
Take-Home Projects
A take-home is a longer async assignment: build this service, implement this feature, produce this analysis. Duration ranges from four hours (claimed) to an entire weekend (actual). Some companies pay for your time, most do not.
The take-home is common at smaller companies, at engineering-heavy startups, and at companies that distrust live coding as a signal. It is most common for backend, data, and infrastructure roles. It is rare at the top of FAANG for full-time roles though still used for some contractor pipelines.
Done well, the take-home is the fairest possible interview because it lets you work at your own pace in your own environment. Done badly, it is the worst because it demands twenty hours of unpaid labor and rewards candidates with free time over candidates with existing jobs and families.
The follow-up is usually a debrief call where an engineer walks through your code with you. This debrief is where most take-homes are actually decided. The code is necessary but not sufficient; you have to be able to defend it.
Pair Programming and Collaborative Rounds
Pair programming rounds ask you to work alongside an engineer on a shared problem, often with an existing codebase. Duration is ninety minutes to two hours. The signal measured is not raw coding skill but collaborative style: how you discuss tradeoffs, how you accept and offer suggestions, how you handle being wrong.
Thoughtworks, Stripe, and a growing set of startups use pair programming as a primary signal. Some companies combine it with a small codebase you receive in advance. You are not expected to finish; you are expected to make visible progress while working with the pair.
Preparation for this round is different from a solo coding round. You practice by pairing with someone, not by grinding LeetCode. The Gilded Rose Kata and similar refactoring exercises are more representative than array-of-integers puzzles.
Company Playbooks: Who Uses What
Every company's loop is specific, but there are clear patterns. The table below is a 2026 snapshot based on recent candidate reports and published recruiting guides.
| Company | Phone Screen | OA | Coding | System Design | Behavioral | Bar Raiser | Take-Home | Pair | | --------- | ------------ | ------------- | ---------- | ------------- | ----------- | ---------------- | --------- | --------- | | Google | Yes | New grad only | 4-5 rounds | Staff+ | Yes | Cross-functional | No | No | | Meta | Yes | Occasional | 2 rounds | Senior+ | Yes | No | No | No | | Amazon | Yes | Yes | 2 rounds | Senior+ | Heavy | Yes, required | No | No | | Apple | Yes | No | 3-4 rounds | Senior+ | Yes | No | Rare | No | | Microsoft | Yes | Sometimes | 3 rounds | Senior+ | Yes | No | No | No | | Netflix | Yes | No | 1-2 rounds | Always | Extensive | No | Sometimes | No | | Stripe | Yes | Sometimes | Live IDE | Senior+ | Yes | No | Common | Yes | | Airbnb | Yes | Occasional | Live IDE | Senior+ | Yes | No | Sometimes | Sometimes | | GitLab | Async | No | Rare | Senior+ | Async-first | No | Common | No | | Zapier | Async | No | Async | Senior+ | Async-first | No | Common | No | | Shopify | Yes | Sometimes | Yes | Senior+ | Life Story | No | No | No |
Patterns worth noticing: big-tech companies still run the most rounds, startups compress the loop, and remote-first companies shift the signal from live coding to async writing and take-home work. Amazon is the only name that consistently runs a true bar raiser.
Sequencing: How the Rounds Stack
A typical 2026 senior engineer loop looks like this:
- Recruiter phone screen (30 minutes)
- Engineer phone screen with one coding problem (45-60 minutes)
- Optional OA or take-home
- Onsite loop (4-6 hours total):
- Coding round 1
- Coding round 2
- System design
- Behavioral / hiring manager
- Bar raiser or skip-level (FAANG only)
For staff and above, one of the coding rounds is often replaced with a deep-dive on past work or a second system design. New grad loops skip system design entirely and double up on coding. Specialist roles (ML, security, infra) replace generic coding with domain-specific problem solving.
The total time investment from first conversation to offer is typically three to six weeks for a single company. Running three or four loops in parallel is routine and almost required if you want real optionality at decision time.
Preparation Checklist by Round Type
- Phone screen: fifteen easy and medium problems, narrated aloud
- OA: timed practice on the specific platform (HackerRank or CodeSignal has its own quirks)
- Coding: fifty to one hundred mediums plus twenty hards, spaced over eight to twelve weeks
- System design: read one canonical book, study ten case studies, do five live mocks
- Behavioral: prepare twelve to fifteen stories mapped to common competencies
- Bar raiser: deepen your behavioral stories with follow-up detail and failure modes
- Hiring manager: research their org, their roadmap, and their last public talk or blog post
- Skip-level: prepare three strategic questions about the business, not the team
- Take-home: build a small portfolio project first so you know your own velocity
- Pair programming: pair with a real engineer on real code at least three times
Frequently Asked Questions
Do all companies run all these round types?
No. A small startup might run three rounds total. A FAANG senior loop might run eight. The round types listed here are the complete taxonomy, not a required sequence.
Which round carries the most weight?
It depends on the level and company. For junior and mid, coding carries the most weight. For senior, the balance shifts toward system design. For staff and above, behavioral depth and past-work deep dives dominate.
Can I skip the OA?
Only if you have a strong internal referral or an exceptional resume. Even then, many companies now route everyone through the OA to keep the process consistent and defensible under audit.
Is the bar raiser just an Amazon thing?
Structurally, yes. Functionally, many companies have a similar concept under different names (calibration interviewers, hiring committees, blind reviewers). The common thread is a veto-holding evaluator who is not attached to the team.
Are take-homes paid?
Sometimes. Stripe historically paid; some startups offer a small stipend. Most do not. Asking politely is reasonable and not a red flag.
How do I prepare for the skip-level without knowing the person?
Read anything public they have written, watch any talk they have given, and understand the org one level above the hiring manager. If you cannot find anything public, prepare generic strategic questions about the business.
Conclusion
The tech interview is not one thing. It is a stack of loosely coordinated formats, each measuring a different signal, each with its own failure modes. A candidate who treats every round the same will pass some rounds by accident and fail others for reasons they never understand.
The fix is to walk into each round knowing its name, its purpose, and the specific signal it is designed to capture. A phone screen is not a coding round. A bar raiser is not a hiring manager chat. A skip-level is not a performance review. Treating them correctly is the quiet half of interview preparation, the half that does not show up on LeetCode counters but decides offers at the margin.
Know the taxonomy, prepare for each round as its own thing, and walk in knowing which signal you need to send. The next five weeks of your life get a lot easier when you do.