"We'd like to move you to the loop" is good news, but it can be confusing news if nobody explains what the loop is. The term gets used loosely, and the details vary between companies, so it's worth understanding the general shape before you start preparing for any one part of it.
This guide explains what an interview loop is, the rounds a typical software engineering loop includes, how long the whole process takes, and how to prepare for a full loop rather than for one round at a time.
What an interview loop is
An interview loop is the set of interviews a company runs to decide whether to hire you. In its narrow sense it means the final stage: several interviews, often on the same day, each with a different interviewer looking at a different skill. That final stage is also called the onsite (even when it's on video), the final round, or the full loop.
People also use "loop" for the whole process, from the first recruiter call to the offer. Both meanings are common. When a recruiter uses the word, it's reasonable to ask which they mean, and what stages it includes.
The idea behind a loop is that no single interview is a fair test of an engineer. Each round looks at one skill, and the hiring decision weighs them together. That's useful to remember: one round going less well than you hoped doesn't decide the outcome on its own.
A typical loop, stage by stage
Loops vary a lot by company size, role, and level, but most software engineering processes are built from the same pieces, roughly in this order.
1. Recruiter screen
A 15–30 minute call with a recruiter about your background, your motivation, logistics, and expectations. It decides whether you move on to the technical stages. Our guide to what to expect in a recruiter screen covers it in detail.
2. Technical screen
One technical interview, usually 45–60 minutes, to check you can do the work before the company commits a full day of interviewers' time. Most often it's live coding (see how to prepare for a live coding interview). Some companies use a take-home assignment instead, or as well, followed by a review call.
Some processes have a short hiring manager conversation at this stage too, mixing background, motivation, and a little technical discussion.
3. The final loop
Typically three to six interviews, each 45–60 minutes. A common set for a mid-level or senior engineer:
| Round | What it looks at |
|---|---|
| Live coding (1–2) | Problem solving, code quality, and communication while coding |
| System design | Scoping an open problem and defending architecture tradeoffs |
| Technical deep dive | Depth of understanding behind past projects and fundamentals |
| Behavioural / leadership | Ownership, collaboration, handling setbacks, and scope |
| Product sense (some roles) | Reasoning about users, priorities, and how to measure success |
Not every loop has every round. Junior loops lean on coding and may skip system design. Senior and staff loops usually include system design and put more weight on the behavioural round. Product-minded roles, and engineering roles at smaller companies, are more likely to include a product round or a conversation with a founder.
The rounds may be scheduled back to back on one day, or spread across several days. A full day of interviews is tiring, so expect breaks, and ask for one if they aren't offered.
4. The decision
After the loop, interviewers write up their notes independently, then the hiring team discusses them together (sometimes called a debrief or hiring committee). This is where the rounds are weighed against each other and against the level. It can take anywhere from a day to a couple of weeks.
5. Offer and negotiation
If the decision is positive, the recruiter calls with an offer. This conversation is part of the process too, and worth preparing for: what you say on this call affects the package you accept. We'll cover offer negotiation in its own guide.
How loops differ by level and company
The same title can come with very different loops. A few patterns are worth knowing:
- Junior and graduate roles lean heavily on coding: often two or three coding rounds, a behavioural conversation, and rarely system design. Interviewers look for fundamentals and how you learn.
- Mid-level roles usually add a system design round and expect a workable design with sensible components. Behavioural stories should show ownership of features end to end.
- Senior and staff roles put more weight on system design and the behavioural round, and often add a technical deep dive into past projects. The interviewer expects you to lead the design discussion and tell stories with influence beyond your own team.
- Larger companies tend to have more standardised loops: the same rounds for every candidate at a level, interviewers trained to assess specific competencies, and a separate decision step after the loop.
- Smaller companies and startups vary more. Some replace coding puzzles with a practical take-home or a pairing session on their own codebase, and many include a conversation with a founder about product and motivation.
- Specialist roles (frontend, mobile, infrastructure, data) often swap a general round for a specialist one: a frontend architecture discussion instead of distributed systems design, for example.
None of this is fixed, which is why asking the recruiter is worth more than any general guide, this one included.
How long the whole process takes
From the recruiter screen to an offer, a few weeks is common, and longer processes of a month or two aren't unusual, especially when scheduling the final loop takes time. Smaller companies often move faster.
You can ask the recruiter for the expected timeline at the first call. If you're in other processes, telling the recruiter roughly where you are helps them plan, and sometimes speeds things up.
How to find out what your loop includes
You don't have to guess. Three good sources:
- The job description. Many postings describe the process outright. Others hint at it: "pair with us" suggests collaborative live coding, "work sample" suggests a take-home, and scope words like "lead" and "across teams" suggest system design and a heavier behavioural round. Our guide to preparing from the job description goes through this step by step.
- The recruiter. Ask what the stages are and what each round covers. Most recruiters will tell you, and some send a preparation guide.
- The company's own materials. Some companies publish how they interview. Read it, but don't take it as a list of real questions.
How to prepare for a full loop
Preparing for a loop is different from preparing for one interview. You have several rounds that test different skills, often within a few hours of each other.
Write the loop down. List the rounds you expect, in order. That list is your preparation plan.
Prepare in the order of the loop. The recruiter screen and technical screen come first and decide whether the rest happens. Don't spend three weeks on system design before you've rehearsed your background.
Give each round its own practice. The skills don't transfer as much as you'd hope. Being good at live coding doesn't make you good at telling a behavioural story, and both need practice out loud. For the design round, a consistent structure helps more than anything (see our 45-minute system design framework); for the behavioural round, prepare six to eight stories and know them well (see the STAR method for software engineers).
Practise stamina, not just skill. If your final loop is four or five interviews in a day, do at least one practice day with two or three rounds back to back. Concentration in the fourth interview is a different thing from concentration in the first.
Keep notes between rounds. If the rounds are spread over days, write down after each one what you were asked and what you'd like to say more clearly. Interviewers sometimes pick up threads from earlier rounds.
Prepare your questions too. Every round ends with "what questions do you have?", and in a full loop you may hear it five times in a day. Prepare a different question or two for each kind of interviewer: an engineer can tell you about the codebase and on-call, a manager about how the team plans and grows people, and a product partner about how decisions get made. The answers help you decide whether you want the job, which matters as much as their decision about you.
On the day of the final loop
- Ask for the schedule in advance: interviewers, rounds, and breaks.
- Treat each round as a fresh start. If one round felt difficult, put it aside. The next interviewer hasn't seen it, and the decision weighs all of them.
- Eat, drink water, and use the breaks to step away from the screen.
- Prepare questions for each interviewer. You'll be asked at the end of every round, and different questions for different people (an engineer, a manager, a product partner) go better than the same three each time.
Hardmode builds an interview plan from a job description: it reads the posting (and your CV, if you add one), works out which rounds the loop is likely to include, and lets you practise each one in order. Plans are inferred from the posting, not from any company's real questions, so treat them as a well-informed starting point and adjust once the recruiter tells you more.