Home Insights Blogs Software Engineering

Signs Your Development Partner Is Failing You — and What the First 90 Days Should Look Like

Arpit Pokharna Arpit Pokharna
Last updated: 10 Aug 2026
Get an AI summary of this post on Perplexity ChatGPT Gemini

Delivery keeps slipping, and no one can give you a straight answer about why. The demos still look fine and the status calls stay upbeat, yet the roadmap drifts another quarter to the right. If that is where you are, the hard part is not fixing the problem. It is naming it, because a struggling development partnership rarely fails in one clear moment. It comes apart slowly, one unremarkable week at a time, until a delay you can feel finally becomes one you can prove.

A partnership shows its real health at two moments: when it is going wrong, and in the first 90 days, where most of that outcome is actually set. This piece covers both. First, the seven signs a current partner is holding your product back, and how to read them. Then what a healthy first 90 days should look like, so you can hold the next start (or this one) to a real standard, and decide whether to repair the engagement or leave it.

Why a Failing Partnership Is So Hard to Spot

Most vendor problems do not announce themselves, because the visible layer keeps working. The weekly demo shows a polished screen. The status deck is green. The account manager is warm and responsive. None of that touches the things that actually decide an engagement: who is really writing the code, whether estimates mean anything, how fast bad news travels, and whether you could leave if you had to.

That gap between the visible layer and the real one is why smart engineering leaders sit on a failing partnership for two or three quarters. They keep waiting for a single, obvious failure to justify a hard conversation, and it never comes, because the failure is distributed across dozens of small slippages that each look survivable on their own. The way out is to stop waiting for the smoking gun and start reading the behavioural signals instead.

7 Signs Your Development Partner Is Holding You Back

No single item below is damning. Everyone has a bad sprint. What matters is the pattern: three or more of these, sustained over a month or two, means the problem is structural rather than circumstantial.

The signWhat it really signalsYour move
Output slows and no one can tell you whyWeak engineering ownership, or a problem being hiddenAsk for the cause in writing; a strong partner can name it
Everything is “almost done”No real definition of done; status you cannot trustRedefine done as shipped to production, not “code complete”
Estimates are always confident and always wrongSales-driven estimation, not engineering-drivenAsk for ranges and a hit rate; track promised against actual
You only ever talk to account managersA team you cannot see; possible bait-and-switchInsist on direct access to the engineers doing the work
Bad news reaches you lateA culture that hides risk until it is unrecoverableBuild an escalation path; reward early warnings
The system lives only in their headsLock-in by design; fragile continuityRequire docs and knowledge in your repositories
Your team manages the partner more than it buildsThe partnership is a net drain, not a multiplierMeasure the management time; a partner should reduce it

Three of these deserve extra weight, because they are the ones that predict the worst outcomes. “You only ever talk to account managers” is the most common way engagements go wrong: the senior people who won the deal are not the people staffing it, and the account layer exists partly to keep you from noticing. “Bad news reaches you late” is expensive precisely because timing is everything in delivery; the gap between a recoverable slip and a full crisis is how early you hear about it, and a partner who manages your perception instead of the risk will cost you a release. And “the system lives only in their heads” is the one that traps you: undocumented work is not just fragile, it is leverage, and a partner who benefits from you being unable to leave has little reason to improve.

Read the signs as two groups, not one score

Do not tally these into a verdict. What matters is which signs cluster together. Signs about process (estimates, “almost done”, slowing output) are usually fixable with clearer governance and honest pressure, and a decent partner will respond to them. Signs about trust and access (hidden bad news, no line to the engineers, knowledge locked in their heads) are far more serious, because they mean you can neither see nor steer what is happening, and you cannot easily walk away. Two process signs are a conversation worth having. Two trust signs mean you should already be planning your exit.

The First 90 Days: What a Healthy Start Looks Like

Here is the pattern behind most failed engagements: the failure was visible in week three, and everyone hoped it would sort itself out. Onboarding a new team should not consume a whole quarter before any code ships. A good partner ramps productivity in stages rather than disappearing and returning at the end with a reveal.

Use the checkpoints below in both directions. If you are onboarding a new partner, this is what to expect. If you are deep in a struggling one, run it backwards and it will tell you how far off track you already are.

MilestoneHealthyWarning
Day 30Environment access sorted, named engineers you have met, a first small change shipped to productionStill “setting up”, no code, only a project manager to talk to
Day 60Predictable delivery rhythm, first real feature live, estimates starting to holdScope confusion, the same context re-explained weekly, first milestone already slipping
Day 90Team ships largely on its own, you trust the status, knowledge is landing in your repos and docsStill hand-holding, status you cannot trust, critical knowledge only in their heads

A healthy first 90 days is a two-way setup

The mistake most buyers make is treating onboarding as something the partner does to themselves while you wait. It is not. The ramp depends as much on what you provide as on the partner’s competence, and the fastest engagements are the ones where the client comes ready with three things: access on day one (repositories, environments, accounts, and the credentials that unblock real work), a real first task that is small but ships to production rather than a throwaway exercise, and an available decision-maker who can answer product questions in hours rather than weeks. A partner who pushes you for those things in week one is not being difficult. They are showing you exactly how a healthy start is built, and a partner who does not ask for them is telling you they are content to bill the ramp.

Onboarding a new partner soon?

We start the healthy way: engineers you can talk to, and real output shipped in the first few weeks.

Explore custom development

Fix It or Switch? A Short Decision Guide

Once you can name the signs, the decision gets clearer. Fix the engagement when the problems are process-level and the partner responds honestly when you raise them: tighten governance, redefine “done”, get direct access to the engineers, and give it a defined window to improve. Switch when the problems are trust-level, or when you are spending more effort managing the partner than the work would take to run in-house.

If you are leaning toward switching, do the next selection deliberately rather than in reaction to a bad quarter, and make the exit from your current partner clean first: confirm you own the code and infrastructure, and get a genuine handover so you do not trade a struggling partner for a knowledge gap.

Also read

What a Healthy Partner Does Differently

Across a couple of hundred engagements, the partners that succeed share a shape. They ship something small and real in the first few weeks instead of disappearing into setup. They put you in direct contact with the engineers writing your code. They raise bad news early, while it is still cheap to fix. And they build the handover as they go, keeping documentation and knowledge in your repositories from the start, which makes them easy to leave. That last habit is the strongest signal of all: a partner confident enough to make leaving painless is usually one you will not want to leave.

The Bottom Line

A failing development partnership rarely announces itself. It accumulates in signs you can feel before you can prove, so learn to read the seven, and separate the process problems you can fix from the trust problems you cannot. Whether you stay or start fresh, hold the first 90 days to a real standard on both sides: access and a real first task from you, small output early and honest status from them. Get that right and you will not be sitting here a quarter from now, watching delivery slip, with no one able to tell you why.

Not sure if your partner is fixable or finished?

Bring us the engagement. We will help you read the signs honestly and start the next partnership right.

Book a Free Call
#Software Development Partner #Vendor Management #Engineering Leadership #Outsourcing #Delivery
Share

Frequently asked questions

What are the signs my software development partner is underperforming?
The clearest signs are: output slowing with no explanation anyone can give you; work that sits at 'almost done' for weeks; estimates that are always confident and always miss; only ever talking to account managers instead of the engineers writing your code; bad news that reaches you late, when it is already too big to fix cheaply; system knowledge that lives in their heads rather than your repositories; and your own team spending more time chasing the partner than building. One of these is a bad week. Three or more, sustained, is a pattern, and the pattern is what matters, not any single incident.
How do I know if I should switch development partners?
Separate the problems you can fix from the ones you cannot. Slipping estimates, thin communication, and shallow documentation are usually process problems you can correct with clearer governance and honest pressure. The problems that justify leaving are about trust and lock-in: a partner who hides bad news, will not let you meet the engineers, or keeps knowledge in their heads so you cannot leave. If the issues are structural and trust is gone, or you are spending more effort managing the partner than the work would take to run yourself, it is time to switch. If they are process gaps and the partner engages honestly when you raise them, fix first.
What happens in the first 90 days with a new development partner?
The first 90 days decide the whole engagement. A healthy start looks like this: by day 30 you have environment access, named engineers you have actually met, and a first small change shipped to production; by day 60 there is a predictable delivery rhythm and the first real feature is live; by day 90 the team ships largely on its own, you trust the status you are given, and knowledge is landing in your repositories and documentation. If day 30 is still 'setting up', with no code and only a project manager to talk to, that is an early warning the engagement is already drifting.
How long before a new development team is productive?
A good partner ships a small, real production change within the first few weeks and a meaningful feature within roughly 60 days. Productivity should ramp, not wait for a big reveal at the end. Onboarding that eats a whole quarter before anything ships is a warning sign, not a norm. The ramp depends as much on the quality of your onboarding (access, a documented first task, a decision-maker who is available) as on the partner's competence, so a partner who pushes for those things in week one is showing you how a healthy start is built.
Should I fix a struggling partnership or switch partners?
Fix it when the problems are process-level (estimation, communication rhythm, unclear ownership) and the partner changes behaviour when you raise them. Switch when the problems are trust-level (hidden bad news, no access to the real team, deliberate knowledge lock-in), or when managing the partner costs you more than running the work yourself would. Before you switch, make the exit clean: confirm you own the code and infrastructure, and get a real handover, so you do not trade a struggling partner for a knowledge gap.
How do I avoid vendor lock-in with a development partner?
Design for exit from day one. Own your repositories, cloud accounts, and IP from the first commit; require documentation and knowledge transfer to be continuous rather than a final-week scramble; and put a defined offboarding process in the contract. If you are already mid-engagement, start reclaiming ownership now: move everything into your accounts, document the system as it stands, and have your people shadow the partner's engineers on the critical paths. A partner confident in their work makes leaving easy, which is usually why clients stay.
Arpit Pokharna
Delivery Manager, Kansoft

Delivery Manager at Kansoft with 15+ years in project management and software delivery leadership. A certified PMP, he writes about delivery governance, project execution, and keeping complex engagements on track.

Related articles

Need help with your next project?

Our engineering experts can help you build something exceptional.

Book a Free Call