How to Replace an Underperforming Developer Without Stalling Delivery

Replacing an underperforming developer works when you do four things in order: confirm the problem with evidence, give a fair and time-bound chance to improve, make the exit decision within U.S. employment rules, and protect delivery while the seat is refilled. Skip the first two and you risk losing a developer who could have recovered. Skip the last two and you risk legal exposure and a team that slows to a crawl. This guide walks through each step with the practical detail a manager needs.
TL;DR
- Look for patterns backed by documents (missed deadlines, deliverables that fell short, teammates working around the person), not gut feelings.
- Separate skill gaps from will problems. Skill gaps often respond to coaching; will problems need a different response.
- A performance improvement plan (PIP) with measurable goals, named support and a clear time frame is the usual fair step before a replacement decision.
- Apply standards consistently, treat accommodation requests properly, and check your state’s rules on final pay and notice before any termination.
- Start the knowledge transfer and the backfill search early so the team keeps shipping.
Table of Contents
- Confirm the problem before you act
- Work out whether it is a skill problem or a will problem
- Give a fair chance to improve
- When replacement is the right call
- Stay on the right side of U.S. employment rules
- Protect delivery during the handoff
- Fill the seat quickly
- Onboard the replacement so history does not repeat
- Replace the seat without the hiring headaches
- FAQ
- Sources
Confirm the problem before you act
The most expensive mistake is acting on a feeling. A developer who seems slow may be blocked by unclear requirements, a painful review process or a time zone gap. Before you decide anything, collect evidence.
GitLab’s handbook lists the patterns that tend to signal real underperformance: lack of results, delayed response times, missed goals and timelines, and other team members working around the individual (GitLab Handbook). The last one is telling. When peers quietly route around someone, the problem is usually already affecting the team.
Managers also need records. Guidance for new managers is blunt that observations should be backed by missed deadlines, specific deliverables that fell short and documented patterns, because gut feelings alone are not a sound basis for a performance conversation (LeadWise). Keep dated, factual notes from the start. The University of British Columbia’s manager toolkit recommends the same: raise concerns early in honest, clear conversations and keep objective notes (UBC).
Use metrics as a lens, not a verdict
Numbers help, but only the right ones. McKinsey’s work on developer productivity describes DORA metrics as measuring outcomes, while the SPACE framework looks at well-being, performance, activity, communication and collaboration, and efficiency and flow (McKinsey). Using several dimensions guards against judging someone on commit counts alone. We cover this in more depth in our guides on diagnosing remote developer performance with SPACE and DORA and on the activity traps SPACE exposes.
Git data can add a signal too. A TechCrunch piece on using repository data in reviews notes that churn above the typical 15% to 30% range can indicate a developer is struggling, and that many high-risk commits suggest best practices are not being followed (TechCrunch). Treat these as prompts for a conversation about the work, never as a score that decides the outcome.
If you track commitments in GitHub, automated reminders on due dates can make slipped promises visible without anyone having to chase them by hand, as described in this walkthrough of GitHub issue reminders. That kind of record turns a vague impression into a timeline you can discuss calmly.
Work out whether it is a skill problem or a will problem
GitLab distinguishes skill-based from will-based underperformance. Skill gaps may call for coaching or training. Will-based concerns, where the person can do the work but is not engaging with it, need a different kind of remediation (GitLab Handbook).
This distinction changes everything that follows. Ask yourself:
- Were expectations clear, written and understood? If not, fix that first.
- Does the developer have the access, tools and context to succeed?
- Is the gap in a specific skill (testing, system design, reading legacy code) or across the board?
- Has the person’s output changed over time, or has it always been this way?
- Is anything outside work affecting performance that they might want to raise?
A developer hired for the wrong level of seniority is a common skill-fit problem. A mismatch in how someone communicates and collaborates is a common cultural-fit problem. Both are cheaper to prevent than to fix, which is why structured screening matters. Our behavioral interview guide for developers covers the questions that surface these issues before an offer.
Give a fair chance to improve
Address underperformance early. One engineering management guide warns that letting it slide can blindside the employee later and erode trust on the team, while clear support gives the person a genuine chance to improve (Software Engineering Guide).
Start with a direct conversation
Name the specific gap, show the examples, and ask for the developer’s view. Often this one conversation reveals a blocker you did not know about. Write a short summary afterward and share it.
Build a time-bound improvement plan
For repeated or multiple deficiencies, a structured PIP gives a roadmap and support. SHRM suggests a duration somewhere between 30 and 90 days depending on the goals and metrics involved (SHRM). The U.S. Office of Personnel Management notes that a PIP normally spans 30 business days, and that it should set measurable goals, identify the support the employee will get, and explain the possible consequences of failing to improve (OPM).
For a developer, a workable plan might include:
- Two or three outcomes, such as shipping scoped tickets by agreed dates and reducing review rework.
- A weekly check-in with written notes.
- Named support: a pairing partner, a mentor, a training budget or clearer specs.
- A checkpoint at the midpoint to say honestly how it is going.
The plan should be fair to the developer and measurable for you. Frameworks for managing vendors and outside teams apply here as well; this overview of vendor performance management shows how to set expectations and review them on a rhythm. If the developer is a contractor, our guide to performance management for contractors covers how that differs from managing an employee.
Improve the system around them
Before blaming one person, check the surrounding process. Slow reviews, handoffs across time zones and unclear priorities all look like underperformance from the outside. Our pieces on remote code reviews and timezone management address the most common sources of delay.
When replacement is the right call
SHRM advises considering further action when an employee fails to make sustained improvement during a PIP. Options include further discipline, demotion or transfer. For safety threats, serious insubordination or work refusal, immediate corrective action up to removal may be appropriate (SHRM). In another SHRM piece, the point is simpler: if support, coaching and tools have been provided and nothing has changed, it might be time to let the person go (SHRM).
Harvard Business Review adds a useful frame: distinguish between rule violations and situations where someone simply does not meet expectations despite exhaustive support (HBR). The first can justify faster action. The second demands that you can show the support you gave.
Is a transfer better than an exit?
Sometimes. If the developer has valuable skills for another group and the negative impact is limited to the current team, a transfer may be an option (The Modern Art of Software Leadership). This works for team-specific friction. It does not work when the underlying issue is quality, reliability or conduct, since you would be moving the problem.
A simple decision test
Replace when all of these are true:
- Expectations were clear and documented.
- You provided real support for a defined period.
- The gaps are still present and affect delivery or the team.
- A different role or team would not fix the cause.
Then act decisively, with dignity, honesty and respect. Dragging it out hurts the developer, who deserves clarity, and the teammates picking up the slack.
Stay on the right side of U.S. employment rules
This section is general information, not legal advice. Talk to HR and an employment attorney before any termination, especially if the developer is in a protected situation or the state has specific rules.
Apply standards consistently. The EEOC’s guidance says employers should apply job-related performance standards to employees with and without disabilities alike. If an employee requests an accommodation, discuss the request and begin the interactive process, without excusing poor performance (EEOC). The same guidance says an employer need not excuse poor performance or hold back warranted discipline, including termination, for problems that occurred before the accommodation request. This is where your dated notes prove their worth.
Avoid retaliation. EEO laws prohibit retaliation for protected activity, such as filing a complaint. Employers can still discipline or terminate for otherwise valid, non-retaliatory and non-discriminatory reasons (EEOC). Check the timeline: if a developer raised a complaint recently, talk to counsel before moving forward.
Check notice and final pay. The federal Fair Labor Standards Act does not require a discharge notice, a reason for discharge, or immediate payment of final wages, but some states have laws on these issues (U.S. Department of Labor). Look up your state before the conversation.
Know when WARN applies. The WARN Act matters for large reductions, not an individual performance exit. Covered employers with 100 or more full-time workers, or 100 or more workers totaling 4,000 weekly hours, must give 60 days’ notice for covered plant closings and mass layoffs (U.S. Department of Labor). If you are replacing several people at once, ask counsel whether it is in play.
If the developer is a contractor rather than an employee, the contract terms govern notice and termination, so read them first.

Protect delivery during the handoff
Losing a developer can slow a team more than keeping a weak one, unless you plan the transition. NASA’s guide on sustaining knowledge through transitions suggests a legacy discussion, sharing work documents, assessing knowledge gaps, and using a knowledge audit or inventory plus a knowledge map (NASA). For software, translate that into practice:
- Inventory what they own. Services, repos, scheduled jobs, credentials, vendor accounts and open pull requests.
- Hold a structured walkthrough. Record it. Focus on the parts that are not in the code: why decisions were made, known fragile areas, unfinished work.
- Reassign explicitly. Give each owned item a named new owner.
- Rotate access. Remove credentials and update secrets on the day of departure.
- Review recent work. A short audit of the last few merged changes can catch hidden problems early.
The same NASA guide notes that teams can divide assignments among peers to ease the increased workload, and that those taking on stretch assignments should be supported by managers, mentors and peers (NASA). Be honest with the team about what will slip. Overloading remaining developers for months is how one departure turns into three.
Fill the seat quickly
Once the decision is made, the clock starts on the backfill. The main routes look like this:
| Option | Best when | Main consideration |
|---|---|---|
| Redistribute work among peers | The gap is short and the team has capacity | Sustainable only for a brief period |
| Internal transfer | Someone has the skills and wants the move | Creates a second gap elsewhere |
| Direct hire | You need a long-term employee in a specific location | Longest lead time; see our developer hiring time guide |
| Nearshore staff augmentation | You want a vetted developer working in your time zone, fast | Needs good onboarding and clear ownership |
| Outsourced project team | The work is a defined project | Less day-to-day control; compare in our outsourcing vs staff augmentation guide |
Whatever route you pick, the replacement should be screened for both technical skill and fit, since the original problem often began with a weak match. Hiring from scratch involves a lot of overhead, which is why many teams use a partner for sourcing and contract management. Our guide on sourcing software engineers with skills-based hiring shows how to set that up.
What about AI as the replacement?
Some managers wonder whether an AI coding tool can simply fill the gap. AI assistants can speed up repetitive tasks for a developer who already knows what good looks like, but they work best with an engineer who can specify, review and own the result. We would treat AI as a multiplier for a strong developer, which is why we also place engineers who are comfortable working with AI tools. For any specific claim on what AI can reliably do, check current research from your own tooling vendors and your security team before you build a plan around it.
Onboard the replacement so history does not repeat
A new developer faces the same traps that sank the last one: unclear expectations, slow reviews, missing context. Set up the first 30 days deliberately:
- A written scope for the first project, with a definition of done.
- A buddy for questions and a named reviewer who turns around code quickly.
- Weekly one-on-ones with written notes from day one.
- A shared view of the metrics you will use and how often you will review them.
For distributed or nearshore developers, add a short working-hours overlap and clear escalation paths. Our three research-backed rules for managing nearshore teams cover this in detail.
Perspective
In our experience, a large share of developer replacements trace back to the hire, not the person. Teams screen for coding ability and forget to test how someone communicates, takes feedback and fits the way the team works. That is why our recruitment and assessment process looks at technical skill and cultural and business alignment together.
When a seat does open, speed matters, but so does repeating the process properly. We believe in a short, honest cycle: clear expectations, real support, a fair decision. Then a vetted replacement who can start contributing without months of paperwork, because we handle the contracts and the bureaucracy on our side.
Our engineering team stays involved after placement, so clients are not left alone with onboarding. We designed our nearshore model around Brazilian developers who work in time zones close to U.S. teams, which keeps standups, reviews and pairing sessions in real time.
Gabriel
Replace the seat without the hiring headaches
If you have reached the point of replacing a developer, you do not need to restart a months-long search. We at Amazing Devs provide pre-vetted nearshore developers from Brazil through nearshore staff augmentation, with sourcing, technical and cultural fit assessment and contract management handled for you.
If you want to add capacity to an existing team rather than swap one person, our Team Extension Model is built for that. For testing gaps, see our nearshore QA contractors, or start from our main page to tell us about the role.
FAQ
How long should a performance improvement plan last for a developer?
The U.S. Office of Personnel Management says a PIP normally spans 30 business days, while SHRM describes 30 to 90 days depending on goals and metrics. Pick the length based on how long it takes to show the outcomes you set, and write the checkpoints down.
Can I replace a developer without a PIP?
In many U.S. situations employment is at will, but skipping documented support makes the decision harder to defend and unfair to the person. Serious misconduct, safety threats or refusal to work may justify faster action. Check your state’s rules and speak with HR or an employment attorney first.
What if the underperforming developer asks for an accommodation?
Discuss the request and begin the interactive process. The EEOC says you still apply the same job-related standards and need not excuse poor performance, including problems that came before the request. Document everything and involve HR.
How do I keep the team shipping while I find a replacement?
Run a knowledge inventory, reassign owned items by name, and divide work among peers for a short period with real support. Then fill the seat with a screened developer so the stopgap does not become permanent.
Should I transfer a weak developer to another team instead?
Only when the issue is limited to the current team and the person has skills another group needs. If the problem is quality, reliability or conduct, a transfer moves the problem rather than solving it.
Sources
- Underperformance, The GitLab Handbook
- Yes, you can measure software developer productivity, McKinsey
- Use Git data to optimize your developers’ annual reviews, TechCrunch
- Tackling Underperformance as a New Manager, LeadWise
- Underperformance: A step-by-step guide for managers, UBC
- Engineering management, Software Engineering Guide
- Addressing and Resolving Poor Performance, OPM
- PIPs: Write, Implement and Time Them Precisely, SHRM
- Here’s How Managers Can Help Underperforming Employees, SHRM
- How to Decide Whether to Fire Someone, HBR
- To coach, separate, transfer or demote, The Modern Art of Software Leadership
- Applying Performance and Conduct Standards to Employees with Disabilities, EEOC
- Small Business Fact Sheet: Retaliation and Related Issues, EEOC
- Fair Labor Standards Act Advisor, U.S. Department of Labor
- Employer’s Guide to Advance Notice of Closings and Layoffs, U.S. Department of Labor
- Sustaining Knowledge Through Transitions Guide, NASA
- Vendor Performance Management: A Practical Guide
- GitHub Issue Reminders
