Interviewing as a Contractor: What's Different and How to Prep

The standard interview-prep advice is written for full-time hires. Whiteboard a binary tree, do five system design mocks, polish your STAR stories, negotiate hard on equity. None of that maps cleanly to a contract role.

Contract interviewing is a different game. The technical bar moves, the loop is shorter, the money conversation happens earlier and is more concrete, and the past-work narrative looks completely different. Done right, contracting can pay 50-100% more than equivalent FTE work and let you skip months of process. Done wrong, you end up underpaid, on a chaotic engagement, with a client who treats you like an FTE who happens to have a 1099.

Here is how to prep.

The Technical Bar Shifts With Engagement Length

The single biggest variable is how long the contract is. The shorter the engagement, the lower the technical bar in the interview - and the higher the bar on day one when you actually start.

Short engagement (2-12 weeks):

The client has a specific problem and needs it solved fast. They cannot afford a 5-round loop and they cannot afford to invest in onboarding you. The interview is usually:

A 30-minute call with the engineering manager or tech lead.
Sometimes a 60-90 minute technical conversation - more "walk me through how you would approach X" than "implement Y on the whiteboard."
Reference checks (almost always). Past contract clients are the cleanest reference signal.
A quick chat with whoever you will work with day-to-day.

The bar in the room is "can this person ramp in a week and ship?" The bar after you start is "did you actually ramp in a week and ship?"

What this means for prep: spend less time on Leetcode, more time on being able to articulate, in 5 minutes, exactly how you would approach the kind of work in their JD. They will ask. Have a clear answer.

Medium engagement (3-9 months):

This is the most common range and the most variable bar. Some clients run a 4-5 round loop nearly identical to FTE; others run a single 90-minute conversation. Roughly:

Recruiter / agency screen if going through one (30 min).
Technical screen with someone on the team (60 min). Often a real coding exercise - paired or take-home, less often whiteboard.
System design or architecture round (60 min) - especially for backend, infra, or platform contracts.
Manager / cultural round (30-60 min).

The bar here is "FTE-equivalent skills, but with the maturity to operate without the FTE-level support structure." They are not training you. They are not pairing you for a month. Show up senior or do not show up.

Long engagement (12+ months) and "contract-to-hire":

These look almost exactly like FTE interviews. 4-5 rounds, full coding loop, full system design, full behavioral, often the same loop the client runs for FTEs. The only real difference is the absence of the equity / level conversation.

If you are going contract-to-hire, treat it as an FTE interview. If you are going long-term contract with no conversion path, you can ask whether they will trim the loop (some will - "we don't need to put you through the full FTE process if you are not going to be on the FTE path").

What's Actually Asked in the Technical Round

For a typical mid-engagement contract role, the technical round looks more like:

A real-world coding exercise. Often a take-home (2-4 hours, max). The signal the client wants: can you ship something clean, with reasonable tests, that solves the actual problem they will throw at you on day one. They are not testing whether you can invert a binary tree.

What clients want to see in take-homes:

Code that compiles and runs without 30 minutes of setup.
Reasonable structure - small files, clear naming, separation of concerns.
A README that says how to run it and what tradeoffs you made.
Tests that actually test something useful (not 100% line coverage on getters).
Realistic time investment (4 hours, not 20 - and it is fine to ship the 4-hour version with a "here is what I would do with another day" section).

A "walk me through your last project" deep dive. Usually 30-45 minutes. They are looking for specificity: actual technologies, actual numbers, actual decisions you made and why. "We used microservices because they scale" is the wrong shape of answer. "We split the monolith into a payments service and a user service first because those had the most divergent scaling profiles - 200 QPS for payments, 50K for user reads" is the right shape.

Architecture / system design. Usually a 45-60 minute conversation, often grounded in something the client is actually building. "We are about to migrate this thing from Postgres to DynamoDB - walk me through how you would think about that." Strong contractors love this format because it is real work; weak contractors choke because they cannot riff without a memorized template.

Light algorithms. Sometimes one easy-medium leetcode problem, mostly to confirm you can write code. Rarely the gating signal.

The Rate Conversation Happens Early

This is the biggest format difference. In FTE interviews, comp comes up at the end. In contract interviews, it usually comes up in the first call.

The recruiter or hiring manager will ask: "What is your rate?" Sometimes "What is your day rate?" Sometimes "What budget are you working with?"

Have a number ready. Hesitating signals you are inexperienced. Naming a number that is way off market signals the same.

Per-hour vs per-day vs retainer:

Hourly. Most common in the US. You bill what you work. Typical for short and medium engagements. Pros: simple, you get paid for the work you do. Cons: client can scope-flex you in unpredictable ways; you have to track hours; some clients will nickel-and-dime overtime.
Day rate. Standard in the UK and Europe, growing in the US for senior contracts. You bill a flat day, regardless of hours worked. Pros: protects you from "do you have 10 minutes" creep; aligns better with senior-level work where some days are 4 hours and some are 12. Cons: clients sometimes expect a 10-hour day for the price of an 8-hour day.
Retainer / monthly. Less common, mostly for fractional senior roles (fractional CTO, fractional principal engineer). Flat monthly fee for guaranteed availability and a defined scope. Pros: predictable income. Cons: scope creep is real; without a hard cap, you can end up working FTE hours for retainer money.
Project-based / fixed-fee. Avoid unless you have done it many times. Software estimates are wrong, and you eat the variance. The exception: very tightly-scoped, well-defined work where you have done the same thing before.

Typical 2026 US rates for senior software engineering contracts:

(Cross-check with your specific region, niche, and skill stack - these are starting points.)

Generalist senior backend / full-stack: $90-150/hr or $1000-1500/day
Specialist senior (ML eng, distributed systems, kernel, security, infra/SRE): $130-225/hr or $1500-2500/day
Staff/principal-equivalent generalist: $150-225/hr or $1500-2500/day
Staff/principal-equivalent specialist: $200-350/hr or $2200-3500/day
Fractional CTO / advisory: $300-500/hr or $5K-25K/month retainer (often equity-bonused)

If you are going through an agency, the agency takes a cut - usually 15-30%. The number you negotiate is the bill rate; what hits your bank account is bill rate × (1 - agency cut), minus your taxes.

The negotiation move:

When asked for your rate, give a range. "I usually work between $X and $Y, depending on engagement length and structure. Where in that range I land depends on a few things - happy to go through it." Then ask three questions:

Engagement length and notice period?
W-2 or 1099 (or umbrella, if UK)?
Onsite, hybrid, or remote? Travel reimbursable?

These three answers move your rate by 10-30%. A 3-month W-2 contract pays differently than a 12-month 1099 contract, and pretending they are the same is leaving money on the table.

1099 vs W-2 vs Agency Contracts (US)

A 30-second tax-and-structure primer, because it directly affects your rate.

1099 (independent contractor). You are self-employed. You bill the client; the client pays the full bill rate; you pay your own taxes (federal income + state + 15.3% self-employment tax). You buy your own benefits. You can deduct business expenses. Best for: senior contractors with multiple clients, established LLC, expensive home offices, lots of professional development costs to deduct.

W-2 contract. You are technically an employee of someone (the agency, or sometimes a staffing arm). They withhold taxes. You sometimes get benefits (health insurance, 401k). Lower headline rate but lower tax burden in practice; closer to a regular paycheck. Best for: contractors who do not want to deal with quarterly taxes, contractors who need ACA-alternative health coverage, contractors who plan to convert to FTE.

Corp-to-corp (C2C). You have an LLC; the client pays your LLC; you pay yourself a salary or distributions. Higher take-home if structured well; more administrative overhead. Best for: experienced contractors with an established corporate structure.

The headline rate difference is roughly: a $100/hr W-2 contract is comparable to a $115-125/hr 1099 contract, depending on benefits offered. Do not compare W-2 and 1099 rates directly without adjusting for that delta.

Agency vs Direct

Most contract roles come through one of three channels:

Agency / staffing firm. They do the hunting, you take the work. They take a cut (15-30% of your bill rate). Pros: less hustle, less invoicing. Cons: lower take-home, agency owns the client relationship (you cannot easily renew direct), agencies sometimes lock you into non-competes.

Direct (no intermediary). Client found you, or you found them. You bill the client directly. Higher take-home, full ownership of the relationship. Cons: you do all the sales, you handle invoicing, you eat the gap between contracts.

Marketplace platforms. Toptal, Gun.io, Braintrust, A.Team, Crossover. Marketplaces take a cut similar to agencies but tend to surface more roles faster. Quality varies widely. Best for: contractors who want a steady deal flow without doing direct sales.

Most senior contractors I know mix all three: a few direct clients (highest take-home, longest relationships), one or two agencies (filler engagements), and occasionally a marketplace for a quick gap-fill.

How to Talk About Past Contracts in Interviews

This is where contractors often torpedo themselves. The standard FTE narrative ("I joined Acme in 2022, owned the X system, got promoted to senior in 2024...") does not map to a contract resume.

Use a different shape:

Frame each contract by problem and outcome, not tenure.

Bad: "I worked at Acme from March 2024 to August 2024 as a contractor."

Good: "Acme hired me for 5 months to lead the migration of their billing service from MySQL to Postgres. Walked into a 200K LOC service with no test coverage on the data path. Shipped the migration with zero customer-visible incidents. Stayed on for 2 months after the migration to write the runbooks and hand off to their FTE team."

The framing matters because the FTE-shaped resume reads as "this person can't hold a job." The problem-and-outcome framing reads as "this person ships specific things."

Be specific about the engagement structure. Say "5-month contract" or "fractional, ~2 days/week, 9 months" up front. Hide nothing; it is not a weakness, it is the reality of the work.

Talk about ramp time and handoff. FTEs ramp in 60-90 days; contractors ramp in 1-2 weeks. Interviewers want to see that you can. "First week was code reading and pairing with their tech lead; first PR was day 4; first production deploy was day 12; by week 4 I was the on-call for that service" is a strong story.

Quantify outcomes. Just like FTE interviews, but moreso. Contractors live and die on quantified results because there is no manager-relationship halo to fall back on. "Cut deploy time from 90 minutes to 22" or "shipped 3 features in 8 weeks" or "took the bug count from 14/month to 1/month."

Have a real reference list. Past contract clients should be your cleanest reference. They have seen you work on a finite, observable engagement. Have 3-5 you can call.

Scope-of-Work Conversations

Every contract starts with a scope conversation. Done well, this is the most important hour of the engagement; done badly, it is the source of every fight you will have for the next six months.

Ask these questions in the scope call:

What does success look like in 30, 60, 90 days?
What is in scope, and what is explicitly out?
Who do I report to? Who is my point of contact?
What systems do I need access to? (Get this lined up before day one or you will lose your first week.)
What is the on-call expectation? (Default: contractors do not do FTE-style on-call. Make this explicit.)
What is the meeting load? (Default: as a contractor you should be in fewer meetings than FTEs. Set the expectation.)
What is the notice period for ending the engagement? (Standard: 2 weeks each way for shorter contracts, 30 days for longer.)
What are the terms for scope change? (You should not be doing 50% more work for the same money because the client realized halfway through that they wanted more.)

Get the answers in writing, ideally in a one-page scope-of-work document. Most clients will not write one for you; you write it and ask them to confirm.

When to Push Back

The biggest contractor-specific skill is pushing back on scope, process, and politics without burning the relationship. FTEs absorb organizational dysfunction because they have nowhere else to be. Contractors who absorb dysfunction get exploited.

Push back when:

Scope is creeping. "I want to flag that the original scope was X; what we are doing now is Y. I am happy to do Y, and I want to make sure we update the scope and the timeline."
The client wants you in 8 hours of meetings a day. "I can be effective in 1-2 hours of meetings; beyond that, I am billing you for time I am not actually shipping. Let me know which meetings I should keep."
You are being asked to be on-call without it being in the contract. "On-call was not in the original scope. If you want me on-call, I am happy to discuss either an additional retainer or a separate on-call rate."
The client wants a code freeze, then expects you to continue billing. "I am not going to bill you for time I am not working. Let me know when the freeze ends; I'll re-engage then."

Do not push back when:

The client asks for a quick favor that takes 30 minutes. Do it. Goodwill compounds.
You hit a hard technical problem and the client is anxious. Communicate, do not flinch. Your value as a contractor is higher when things are going badly, not when they are easy.
The client has a process you find dumb but it is not your fight. (Their CI takes 90 minutes and you think it should take 10? Not your problem unless they hired you to fix it.)

The Contractor's Mindset

Two mental shifts separate the contractors who make it from the ones who burn out:

Your job is to ship. Not to be liked. FTE incentives reward being agreeable; contractor incentives reward shipping. Saying no to scope creep is part of the job. Disagreeing with the architecture in week one is part of the job. Pushing for a timeline that is realistic is part of the job. The clients who hire you back are the ones who appreciated the candor, not the ones who liked you the most.

You are not part of the company. This sounds harsh. It is not. It is the freedom that makes contracting work. The internal politics, the promotion cycles, the all-hands meetings, the strategic pivots - none of it is your problem. Your problem is the work in front of you. Show up, ship it, leave clean.

Done well, contracting is the most lucrative and lowest-overhead software engineering career path that exists. Done poorly, it is the worst of both worlds - FTE workload, contractor pay, no benefits. The interview is where the difference starts.

gitGood helps contractors stay sharp on the technical loops without the cruft. $5/month, no fluff.