How to Hire Software Developers: Hiring Models, an 8-Step Process and Mistakes to Avoid
21/09/2023
2.43k
To hire software developers well, decide first whether you need one person or a whole team, then pick the hiring model that matches (in-house employee, freelancer, staff augmentation, dedicated team or project-based outsourcing). After that, run a repeatable process: define the role, write a specific job description, source in several channels, screen against written criteria, give a realistic technical assessment, hold structured interviews scored with a rubric, make a fast and complete offer, and plan the first 90 days of onboarding. Most hiring failures come from skipping the first decision or the scoring rubric, not from a shortage of candidates.
This guide walks through each of those decisions in order. It keeps the five steps from our original 2023 checklist (define your needs, source widely, screen carefully, sell culture and compensation, onboard for growth) and expands them with current data, a model comparison table, a copyable interview scorecard, warning signs and a clear test for when hiring a team beats hiring individuals.
Step 0: Decide Whether to Hire a Developer or a Team
The most important hiring decision happens before any candidate appears: what kind of capacity do you actually need? A single developer fits a well-defined gap in an existing team. A team fits a product, a new platform or a deadline that one person cannot carry alone. Getting this wrong is expensive in both directions. Hiring five individuals for a six-month project leaves you with recruiting cost and headcount you may not need afterwards. Hiring an outside team for a role that holds your core product knowledge leaves that knowledge outside your company.
Ask four questions before you choose a model:
- How long will the need last? Under six months points toward freelancers or project outsourcing. Ongoing work points toward employees or a dedicated team.
- How many roles do you need at the same time? One or two roles can be hired individually. A product that needs front end, back end, QA, a business analyst and a project manager is a team problem.
- Who will manage the work day to day? If you have an engineering lead with time to spare, staff augmentation works. If you do not, you need a model where the vendor supplies management.
- How sensitive is the knowledge? Core intellectual property and long-term architecture usually belong with employees, even if outside partners help build them.
The five hiring models compared
The table below compares the five common models on the factors that most affect cost, speed and risk. It describes typical patterns, not guarantees; every vendor and market differs.
| Model | Best for | Who manages the work | Time to start (typical) | Main risk |
|---|---|---|---|---|
| In-house employee | Core product roles, long-term ownership of the codebase | You | Slowest: full recruiting cycle plus notice period | Long hiring cycle, fixed cost if priorities change |
| Freelancer | Small, well-scoped tasks, prototypes, specialist fixes | You | Fast | Availability, continuity and knowledge loss when the contract ends |
| Staff augmentation | Adding one or more engineers to an existing team with a lead | You, with vendor handling employment | Fast to medium | Needs strong internal technical leadership |
| Dedicated team | Long-running products that need several roles working together | Shared: vendor runs the team, you set priorities | Medium | Requires clear product ownership on your side |
| Project-based outsourcing | Fixed-scope builds with clear requirements and a deadline | Vendor | Medium (scoping first) | Change requests when scope is unclear |
If you are weighing the dedicated team option in detail, our guide to hiring a dedicated remote development team covers that model on its own. For a broader cost and control comparison, see in-house vs outsourcing application development. The rest of this article focuses on the process itself, which applies whether you are hiring an employee or interviewing engineers proposed by a vendor.
Quick decision guide
| Your situation | Model to consider first |
|---|---|
| You have a tech lead and need one more React developer for a year or longer | In-house employee, or staff augmentation if hiring is slow |
| You need a landing page fixed or an integration built in four weeks | Freelancer |
| You need to launch a new mobile app and have no engineering team | Project-based outsourcing or dedicated team |
| Your product roadmap is long and changing, and you need five or more roles | Dedicated team |
| You need a rare skill (for example, a payment certification) for a few months | Freelancer or staff augmentation |
Why the Process Matters: The Market in Numbers
Software developers remain one of the most in-demand professions, which means candidates compare offers and processes. According to the US Bureau of Labor Statistics Occupational Outlook Handbook, employment of software developers, quality assurance analysts and testers is projected to grow 10 percent from 2025 to 2035, with about 106,100 openings projected each year. The same page reports that software developers held about 1.7 million jobs in 2025 and that the median annual wage for software developers was $135,980 in May 2025.
Those numbers describe the US market, but the lesson travels: competent developers have options. A process that takes weeks to schedule interviews, asks for unpaid multi-day projects or cannot explain the role clearly will lose candidates to companies that move faster.
At the same time, a large share of developers are not actively looking. In the 2025 Stack Overflow Developer Survey (Work section), 14.8% of respondents said they were considering a new role strongly and 28.8% somewhat, while 45.6% said they were not looking. The same section ranks “autonomy and trust to manage your own tasks,” “competitive pay and benefits” and “solving real-world problems” as the top attributes developers value in a job. Your job post and interviews should speak to all three.
Work arrangements also shape your candidate pool. In the same survey, 32.4% of respondents worked fully remote and 17.9% fully in person, with the rest in hybrid or flexible setups. If you insist on an in-office role, you are fishing in a smaller pond, so be clear about it early.
The 8-Step Process to Hire Software Developers
The eight steps below form one pipeline. Each step produces an output that the next step uses, so skipping one usually causes problems later. Our original five steps are mapped inside this process: defining needs is Steps 1 and 2, sourcing is Step 3, screening is Steps 4 to 6, culture and compensation are part of Steps 2 and 7, and onboarding is Step 8.
Step 1: Define the role and the outcome
Start with the outcome, not the tech stack. Write one sentence describing what this person will have achieved after twelve months. “Rebuild our checkout so that it handles seasonal traffic without downtime” is a role definition. “Senior full stack developer, 5+ years” is not.
Then list the skills that outcome needs. Our original article used an e-commerce example, and it still works well. If you are building an online store, you need to decide whether you are customizing a platform such as Shopify or WooCommerce or building a custom storefront. That choice changes the role: a Shopify project needs Liquid templates, the Shopify APIs and strong JavaScript and CSS; a custom build may need a back-end framework, database design and payment integration experience.
Use this checklist to complete the role definition:
- Twelve-month outcome in one sentence
- Must-have skills (no more than five)
- Nice-to-have skills (clearly labeled as optional)
- Seniority level and why (who will they mentor, what decisions will they own)
- Team they join, who they report to and who reviews their code
- Working arrangement: remote, hybrid or on-site, and required overlap hours
- Budget range approved by finance before the post goes live
- Hiring model chosen in Step 0
Be strict about the must-have list. Every extra “required” skill shrinks the candidate pool and often filters out people who could learn that tool in a week. Stack Overflow’s 2026 survey found that unclear priorities or requirements were the most common thing that made developers’ jobs harder in the past six months (16.6% of answers on the 2026 Work page). A clear role definition is the first place you prevent that problem for your new hire.
Step 2: Write a job description developers will read
A job description is a sales page for the role. Developers skim for four things: what they will build, which technologies they will use, how the team works and what they will be paid. Put those near the top.
Recommended structure:
- One-paragraph summary: the product, the team and the twelve-month outcome from Step 1.
- What you will work on: three to five concrete projects or problems.
- Tech stack: the real one, including legacy parts. Candidates find out anyway.
- Must-have skills and nice-to-have skills: two separate lists.
- How we work: code review, release frequency, on-call expectations, remote policy and overlap hours.
- Compensation and benefits: a salary range where the law or your policy allows it, plus learning budget, equipment and leave.
- Hiring process: the stages, roughly how long each takes and when they will hear back.
This is also where the “culture and compensation” step from our original guide belongs. Describe your mission and the impact of the work honestly, and explain perks that developers actually use, such as remote flexibility and professional development time. Because pay ranks among the top attributes developers value in the Stack Overflow data above, a missing salary range is one of the fastest ways to lose applicants.
Job description mistakes to avoid:
- Listing ten “required” frameworks
- Asking for more years of experience than the technology has existed
- Vague phrases like “fast-paced environment” or “rockstar” with no detail
- Hiding the remote policy until the final interview
- Copying a generic template that does not match your stack
Step 3: Source candidates in more than one channel
Good sourcing combines active applicants with people who are not looking. Since nearly half of developers in the 2025 Stack Overflow survey said they were not looking for a new role, relying only on inbound applications means you only see part of the market.
| Channel | Strength | Weakness | Best for |
|---|---|---|---|
| Employee referrals | Pre-vetted, often faster to close | Can reduce diversity of backgrounds | All roles |
| Job boards and LinkedIn | Volume and reach | High screening workload | Common stacks, mid-level roles |
| Developer communities (GitHub, Stack Overflow, local meetups) | Visible work samples | Time-consuming outreach | Senior and specialist roles |
| Freelance marketplaces | Fast access, short engagements | Quality varies widely | Short, well-scoped tasks |
| Recruitment agencies | Saves internal time | Fees, uneven fit with niche stacks | Urgent or hard-to-fill roles |
| Software development vendors | Can supply individuals or complete teams | Need to vet the company as well as the people | Staff augmentation, dedicated teams |
Talent matching technology is also changing how sourcing works. For example, SupremeTech built Talenten, an AI-based talent matching platform aimed at connecting the top 10% of talent with Vietnamese businesses. Its Talentmatch feature uses mock video interviews to assess skills and knowledge and suggest suitable jobs, candidates can create personalized video CVs, and recruiters post and manage jobs from a dashboard. Tools like this can shorten the first screening pass, but they do not replace a clear role definition or a structured interview.
Outreach message template (for passive candidates):
“Hi [Name], I saw your work on [specific repository, talk or project]. We are building [one-sentence product] and need someone to [twelve-month outcome]. The stack is [stack], the team is [size and setup] and the range is [range]. Would you be open to a 20-minute call to hear more, with no preparation needed?”
Step 4: Screen resumes and portfolios against written criteria
Screening is where bias and inconsistency creep in, because each reviewer has their own instincts. Write down the criteria before you open the first resume. Use the must-have list from Step 1 and score each candidate yes, partly or no on each item.
What to look for:
- Evidence of shipped work: products, features or open-source contributions they can explain.
- Relevance, not just years: two years on a similar product can matter more than eight years on an unrelated one.
- Code they can show: a GitHub profile, portfolio or code sample. Absence is not a red flag (many developers work on private code), but presence is a useful signal.
- Clear writing: a resume that explains impact usually comes from someone who writes clear tickets and pull requests.
Follow resume screening with a short call (20 to 30 minutes) run by the hiring manager or a recruiter. Its purpose is to confirm motivation, salary expectations, availability and work arrangement, and to explain the rest of the process. It is a two-way conversation, not an exam.
Step 5: Give a realistic technical assessment
Technical assessments should look like the job. Our original article recommended coding tests to understand a candidate’s practical skills, and that advice still holds. The format is what has changed: algorithm puzzles on a whiteboard tell you little about how someone works in a real codebase.
| Assessment format | What it shows | Watch out for |
|---|---|---|
| Short take-home task (time-boxed, ideally paid) | Code quality, structure, tests and documentation | Unpaid multi-day tasks drive good candidates away |
| Live pair programming on a real issue | Communication, reasoning and collaboration | Nervousness; give the candidate setup time |
| Code review exercise | Judgment, attention to detail and seniority | Needs a prepared sample with deliberate issues |
| System design discussion | Architecture thinking for senior roles | Too abstract if not tied to your product |
| Automated coding test | Baseline skill at volume | Weak signal for senior roles; easy to game |
Practical guidelines:
- Keep take-home tasks to a few hours and say how long you expect it to take.
- Score with the same criteria for everyone: correctness, readability, tests, handling of edge cases and explanation.
- Decide your policy on AI coding assistants and tell candidates. If your team uses them daily, assessing how a candidate uses them is more realistic than banning them.
- Always follow a take-home with a discussion. Asking “why did you choose this approach?” reveals more than the code alone.
Step 6: Run structured interviews with a scorecard
Structured interviews mean every candidate for a role gets the same core questions, and interviewers score answers against a shared rubric. Our original article cited Google research on this, and Google’s own re:Work guide to structured interviewing states that structured interviews are more predictive of job performance than unstructured interviews and decrease differences between demographic groups. The same guide reports that pre-made questions, guides and rubrics save an average of 40 minutes per interview, and that rejected candidates who had a structured interview were 35% happier than those who did not.
Use two kinds of questions:
- Behavioral: “Tell me about a time you disagreed with a code review comment. What happened?”
- Hypothetical: “Imagine our checkout error rate doubles after a release on Friday evening. What do you do first?”
Prepare follow-up questions in advance, and agree what an outstanding, solid, borderline and poor answer looks like before the interviews start.
Interview scorecard template
Copy this scorecard into your hiring tool or a shared document. Each interviewer fills it in independently, before discussing the candidate with others.
| Competency | What good looks like | Score (1 to 4) | Evidence (notes) |
|---|---|---|---|
| Technical depth in the core stack | Explains trade-offs, not just syntax; knows when not to use a tool | ||
| Problem solving | Breaks a vague problem into steps, asks clarifying questions, checks assumptions | ||
| Code quality and testing | Readable code, meaningful tests, considers edge cases | ||
| Communication | Explains decisions clearly to technical and non-technical people | ||
| Collaboration and feedback | Gives and receives code review constructively; credits others | ||
| Ownership | Talks about outcomes, follows through, admits and fixes mistakes | ||
| Learning | Describes recently learned skills and how they learned them | ||
| Role-specific item | For example: performance tuning, mobile release process, security practices |
Scale: 4 = outstanding (clear evidence above the level), 3 = solid (meets the level), 2 = borderline (some gaps), 1 = poor (clear gaps). Add an overall recommendation: strong hire, hire, no hire or strong no hire, and one sentence explaining it.
Worked example (hypothetical): A company hiring a mid-level back-end developer runs three interviews. Candidate A scores 3, 3, 4, 2, 3, 3, 3, 3 and Candidate B scores 4, 4, 3, 2, 2, 2, 3, 3. Both total 23, but the notes show Candidate B struggled to explain decisions and dismissed review feedback. Because the team’s main pain point is collaboration across time zones, they choose Candidate A. Without a written scorecard, the stronger technical impression of Candidate B would likely have won the debrief.
How many interview rounds?
Most roles need no more than four stages after the resume screen: the screening call, the technical assessment and its discussion, one or two structured interviews (technical and team), and a final conversation with the hiring manager. Each extra round adds days and gives competing offers time to land. If you cannot reach a decision after four stages, the problem is usually the rubric, not the number of rounds.
Step 7: Check references and make a complete offer quickly

Once the debrief agrees on a hire, move fast. Check references with specific questions (“How did they handle a production incident?” works better than “Were they good?”), then make the offer by phone or video and follow it in writing the same day.
A complete offer includes:
- Base salary and any bonus or equity, with how and when it vests
- Benefits, leave, learning budget and equipment
- Remote or hybrid arrangement in writing
- Start date, manager and first-week plan
- For contractors and vendors: scope, intellectual property ownership, confidentiality, notice period and data security obligations
Compensation is where the original “highlight culture and compensation” step pays off. The BLS median wage of $135,980 for US software developers in May 2025 gives a reference point for the US market; local salary surveys are better for other countries. Whatever the market, an offer that reflects the range you advertised and the candidate’s interview performance avoids late surprises and renegotiation.
Step 8: Onboard for the first 90 days
Onboarding decides how quickly a new developer becomes productive and whether they stay. Our original guide stressed setting clear expectations, sharing core values, giving challenging work and offering a path for growth. A 30, 60 and 90 day plan makes that concrete.
| Period | Goals | Manager actions |
|---|---|---|
| Before day 1 | Accounts, hardware and repository access ready | Send the first-week schedule; assign an onboarding buddy |
| Days 1 to 30 | Local environment running; first small change merged; understands the architecture and release process | Daily check-ins in week one; weekly one-on-ones after that |
| Days 31 to 60 | Owns a small feature end to end; participates in code review | Give feedback on code and communication; adjust scope if needed |
| Days 61 to 90 | Delivers a meaningful feature independently; contributes to planning | Formal 90-day review against the twelve-month outcome from Step 1; agree growth goals |
Onboarding checklist:
- Architecture overview and a written glossary of product terms
- Documented local setup that a new person can follow without help
- A “first issue” list of small, real tasks
- Introductions to product, design, QA and support contacts
- Clear definition of done and code review expectations
- Learning plan and career path discussion (training, conferences, certifications)
- Security and data handling training before production access
If the new developer joins remotely or through a vendor, add overlap hours, communication channels and escalation paths to the plan. Our article on managing offshore development teams effectively covers those routines in more depth.
Red Flags When Hiring Software Developers
Warning signs come from both sides of the table. Watch for these in candidates and in your own process.
Candidate red flags
- Cannot explain their own code: they submitted a strong take-home but cannot walk through the decisions behind it.
- Only “we,” never “I”: they cannot describe their personal contribution to any project.
- Blames others for every failure: no examples of learning from a mistake.
- Dismisses testing, security or documentation as someone else’s job.
- Inconsistent story: dates, titles or project details change between resume, call and interview.
- No questions about the product or team: may signal low interest or poor preparation.
- Refuses any assessment while claiming senior expertise with no visible work.
Process red flags (on your side)
- Interviewers make up questions on the spot and score from memory.
- More than four interview stages, or weeks between stages.
- Unpaid assignments that take more than a few hours.
- The job description and the interview test different skills.
- The debrief is decided by the most senior or loudest person in the room.
- Salary range is unknown until the offer stage.
Vendor red flags (if you hire through a partner)
- You cannot interview the engineers who will actually work on your project.
- No clear answer on who owns the code and intellectual property.
- No information security certification or documented security practices.
- High turnover on proposed team members before work even starts.
- No named project manager or business analyst for communication.
For a full vendor evaluation checklist, see our guide on how to select the right app development team.
Common Hiring Mistakes and How to Fix Them
| Mistake | What happens | Fix |
|---|---|---|
| Hiring for a stack, not an outcome | You hire someone who knows the tools but not the problem | Write the twelve-month outcome first (Step 1) |
| Overloaded must-have list | Few applicants, mostly mismatched | Limit must-haves to five; move the rest to nice-to-have |
| No salary range | Late-stage withdrawals over pay | Get budget approval before posting |
| Unstructured interviews | Decisions based on likability | Use the scorecard and a shared rubric (Step 6) |
| Slow process | Best candidates accept other offers | Set a target for each stage and book interviewers in advance |
| Hiring individuals for a team-sized problem | Months spent recruiting before work starts; roles do not mesh | Revisit Step 0 and consider a team model |
| No onboarding plan | Slow ramp-up, early resignation | Prepare the 90-day plan before the offer is signed |
Hiring Individuals vs Hiring a Team

Most guides on how to hire software developers assume you are hiring one person. In practice, many companies search for a developer when what they really need is a working team: someone to gather requirements, someone to design, developers for front end and back end, QA and a project manager. Hiring each role separately can take months, and the people may not have worked together before.
Consider hiring a team instead of individuals when:
- You need three or more roles to start at roughly the same time.
- You have a fixed launch date that recruiting would put at risk.
- You do not have an engineering lead to manage developers day to day.
- The skills are needed for one product phase (for example, a build and launch), not permanently.
- You need roles that are hard to hire locally, such as business analysts who speak your clients’ language.
| Factor | Hiring individuals | Hiring a team through a partner |
|---|---|---|
| Time to first delivery | Depends on how fast you fill every role | Usually faster, since roles are staffed together |
| Management load | On you: process, reviews, coordination | Shared: partner provides project management |
| Knowledge retention | Stays in your company | Needs documentation and handover planning |
| Flexibility | Lower: changing headcount takes months | Higher: team size can change with the roadmap |
| Fixed cost commitment | Salaries, benefits and recruiting fees | Contracted fees for the engagement period |
| Best fit | Core long-term roles | New products, peaks in demand, specialist phases |
Many companies combine both: they hire a small core of employees who own architecture and product knowledge, and work with a partner team for delivery capacity. The Talenten project mentioned above is a small example of team composition: the case study lists one project manager, one business analyst, one front-end engineer, one back-end engineer and one quality control role covering design, implementation, testing, migration and maintenance. That five-role shape is a useful reference for what “a minimal product team” means when you scope your own needs.
If a team model fits, SupremeTech’s custom software development services offer dedicated team, time and materials and flexible scope engagements. SupremeTech is based in Da Nang, Vietnam, with a presence in Tokyo, and is ISO/IEC 27001 certified. For Japanese clients in particular, our business analysts speak Japanese and join requirement meetings with clients directly, and Da Nang is only two hours behind Tokyo, which gives almost a full shared working day. [SupremeTech detail: how a typical team engagement starts, for example the kickoff and requirement workshop format, to confirm with the delivery team.] Our article on why you should hire an outsourced app development team explains when that route makes sense.
How to Hire Software Developers Through a Vendor: Adjusted Steps

If you choose staff augmentation, a dedicated team or project outsourcing, the eight steps still apply, with a few changes:
- Define the role or team: describe outcomes and the roles you think you need, then ask the vendor to propose a team shape and challenge your assumptions.
- Job description becomes a brief: share product context, constraints, tech stack, security requirements and timeline.
- Sourcing becomes vendor selection: compare two or three partners on relevant experience, communication, security certification and references.
- Screening: review proposed CVs and ask for past work in a similar domain.
- Technical assessment: interview the actual engineers, or run a short paid pilot sprint.
- Structured interviews: use the same scorecard, with extra weight on communication and language skills.
- Offer becomes contract: confirm scope, intellectual property, confidentiality, replacement policy and exit terms.
- Onboarding: grant access, share documentation, agree on ceremonies (planning, demos, retrospectives) and set the first 90-day goals for the team.
Hiring Timeline Template
The template below shows a realistic, compact timeline for one in-house developer when interviewers are booked in advance.
| Week | Activity | Owner |
|---|---|---|
| Week 1 | Role definition, budget approval, job description, scorecard and interview questions | Hiring manager, HR |
| Weeks 2 and 3 | Post the role, start outreach and referrals, screen resumes daily | Recruiter, hiring manager |
| Weeks 3 and 4 | Screening calls and technical assessments | Recruiter, senior engineer |
| Weeks 4 and 5 | Structured interviews and debrief | Interview panel |
| Week 5 | References and offer | Hiring manager, HR |
| After acceptance | Notice period, then 90-day onboarding plan | Manager, onboarding buddy |
Frequently Asked Questions
Decide what capacity you need and which hiring model fits: an employee, freelancer, augmented staff, dedicated team or outsourced project. Then define the role by its twelve-month outcome and a short list of must-have skills.
It varies by market, seniority and model. Freelancers and staff augmentation can start quickly; in-house hires take longer because of interviews and notice periods. Keeping the process to four stages after screening and booking interviewers early shortens it.
Borrow technical judgment. Ask a trusted engineer or advisor to design and score the technical assessment, use a structured scorecard for everything else and focus your own interview on communication, ownership and motivation.
Use whatever looks most like the real job. A short, time-boxed take-home followed by a discussion, or live pairing on a realistic issue, usually tells you more than algorithm puzzles. Avoid unpaid tasks that take days.
Costs depend on country, seniority and model. As one reference, the US Bureau of Labor Statistics reports a median annual wage of $135,980 for software developers in May 2025. Add recruiting, benefits, equipment and onboarding time for employees.
When you need several roles at once, face a fixed deadline, lack an engineering lead or only need the skills for one product phase. A partner team can start sooner and share management work.
Mix behavioral questions (“Tell me about a time you fixed a production issue”) and hypothetical ones (“What would you do if a release broke checkout?”). Ask every candidate the same core questions and score answers against an agreed rubric.
Yes, if you vet the partner, interview the actual engineers, confirm intellectual property and confidentiality terms in the contract and check security practices such as ISO/IEC 27001 certification. Agree on overlap hours and communication routines from the start.












