All articles
OutsourcingNovember 2026 · 10 min read

9 warning signs your development agency is failing you

Missed deadlines, surprise costs, and vanishing support after launch. Nine red flags to watch for, the questions to ask, and the contract terms that protect your project before you commit.

When you outsource software development, you want a partner who delivers on time, communicates well, and builds a product that works. But things don’t always go as planned. Even though the global outsourcing market is worth over $600 billion, project failure rates are still high. Choosing the right vendor is one of the biggest factors in whether your project succeeds or turns into a costly lesson.

Most agencies aren’t completely incompetent. The real issue is that warning signs show up early, but clients often miss them or aren’t sure how to respond. Here are nine signs to watch for, plus questions to ask and contract tips to help protect your project before you commit.

1. They keep missing deadlines without a clear explanation

What it looks like: A feature estimated at two weeks stretches into six. Every status meeting brings a new excuse—unclear requirements, unexpected technical debt, a key developer out sick—but none of these risks were flagged before the deadline slipped.

Why it matters: Delays happen on almost every project. The red flag isn’t the delay itself; it’s the silence that precedes it. Reliable agencies surface risks early, even when the news is uncomfortable. An agency that only admits problems after they become crises is either mismanaging its projects or hiding something.

What to ask: “Walk me through a project that went off track. How did you communicate the problem, and what did you do about it?” Agencies with real delivery experience can answer this specifically. Those who claim they’ve never had a troubled project are either lying or not paying attention.

Contractual protection: Require weekly written status reports with a risk log. Define a communication SLA—for example, “Agency will notify Client of any risk that could affect the delivery timeline within one business day of identification.”

2. You’re constantly discovering new costs

What it looks like: The initial proposal looked affordable. But every feature, integration, or revision becomes an additional line item. Payment gateway integration? Extra. Admin dashboard? That was never included. Basic reporting? You’ll need to pay for a separate module.

Why it matters: This is often a deliberate strategy. Agencies underbid to win the contract, then recover profit through change orders. Fixed-price quotes delivered in the first meeting—before anyone has analyzed your requirements—are a major red flag for exactly this reason. A professional agency will estimate only after understanding your scope.

What to ask: “Can you provide an itemized cost breakdown showing what’s included, what’s excluded, and how changes will be priced?” Also demand clarity on ongoing costs: cloud infrastructure, third-party licenses, and post-launch support are frequently omitted from initial quotes.

Contractual protection: Insist on a written change-control process that defines how scope changes are requested, approved, and priced. The payment milestones should be tied to demonstrable deliverables, not calendar dates, and upfront payment should never exceed 30%.

3. They deliver features that don’t solve your problem

What it looks like: The agency built exactly what was written in the specification. But the specification itself was flawed; nobody asked whether the feature actually addressed the business need. Your fundraising dashboard displays donation totals, but campaign managers still can’t tag recurring donors or understand performance by source.

Why it matters: This is the “feature factory” mindset: success is measured by tickets closed rather than outcomes delivered. It stems from agencies that take orders rather than acting as product partners. A good technical partner pushes back, challenges assumptions, and asks “why” before “what”.

What to ask: “How do you validate that a feature meets the actual business need before development begins?” Look for user story mapping, acceptance criteria tied to measurable outcomes, and UAT sessions with real end-users, not just developers.

Contractual protection: Define acceptance criteria in business terms, not technical ones. “Campaign managers can identify and tag recurring donors in under 30 seconds” is testable. “Dashboard functionality delivered” is not.

4. Communication happens only when you chase them

What it looks like: You send three messages asking about a critical API integration. You get a response during the next scheduled meeting—or later. You’re always the one initiating contact. Meeting minutes are never shared. Technical decisions are explained only when you demand an explanation.

Why it matters: Poor communication is a leading contributor to project failure. More importantly, the communication pattern you experience during sales is usually the one you’ll experience during delivery—just worse. If the sales team is the only one talking to you, and the actual developers are invisible, that tells you exactly how the engagement will work after you sign.

What to ask: “Can I speak directly to the developer who will work on my project—not a salesperson, not an account manager?” If the answer is no, walk away. Also ask to see a sample weekly status report. Vague summaries (“making good progress”) versus specific metrics (cycle time, blockers, completed deliverables) reveal whether they run a delivery operation or a staffing desk.

Contractual protection: Name a specific project manager in the contract, with a defined weekly communication commitment: at minimum, a written summary and two scheduled calls. Establish a shared channel (Slack, Teams) where you have direct access to the technical team.

5. Their developers keep rebuilding the same features

What it looks like: The login feature has been rebuilt three times. Each iteration introduces new bugs. The agency never properly addressed authentication, session management, or single sign-on requirements, so they keep starting over.

Why it matters: Repeated rework signals deeper problems: no code review culture, inadequate automated testing, no coding standards, or high developer turnover that erodes institutional knowledge. Rework can consume 20–40% of development time on poorly managed projects, and you’re paying for every hour.

What to ask: “What percentage of your codebase has automated test coverage?” and “Can you show me an anonymized pull request and its review?” Mature vendors will have real delivery artifacts, architecture documents, retrospective notes, post-incident reviews, ready to share. Less experienced vendors will only show you proposal templates.

Contractual protection: Require code repository access from day one. If they resist giving you read access to the codebase on GitHub or GitLab, they’re either hiding sloppy work or creating lock-in.

6. They don’t test what they deliver

What it looks like: QA is treated as the final step before handover, not an ongoing practice. A donation platform works for one-time payments but fails on recurring donations, refunds, or failed transactions, all of which were in the requirements.

Why it matters: Bugs found in production are exponentially more expensive to fix than bugs caught during development. Many agencies call their manual testers “QA engineers,” but those roles are often limited to executing test cases written by someone else. True quality engineering means test automation, exploratory testing, and regression prevention, not just bug hunting at the end.

What to ask: “What does a QA engineer do day-to-day at your company?” and “How do you handle regression testing between releases?” Also ask whether they load-test for expected traffic; systems that work for 100 users often fail at 1,000.

Contractual protection: Define a “definition of done” that includes code review, automated tests passing, and deployment to a staging environment. If the agency’s definition of done is simply “client approved,” they don’t own quality.

7. Your project depends on one developer

What it looks like: Only one team member understands the codebase, the deployment process, or the critical integrations. When that person goes on vacation—or resigns—progress stops. The agency scrambles to restore access because no documentation exists.

Why it matters: This is called a “bus factor of 1,” and it’s a catastrophic risk. The DORA research on software delivery performance consistently shows that teams with strong documentation and structured handoff processes deliver significantly more stable outcomes than those relying on individual heroics.

What to ask: “What happens if a key engineer leaves mid-project? How quickly can you backfill, and how is knowledge transferred?” Also request the engineer replacement process in writing. This is where bait-and-switch becomes visible: senior engineers in the sales pitch, junior engineers doing the actual work.

Contractual protection: Require documentation as a deliverable: architecture diagrams, deployment instructions, API documentation, and runbooks. Include a knowledge transfer clause. Ask for repository access and infrastructure credentials to be held by you, not the agency.

8. They ignore scalability and technical debt

What it looks like: The platform performs fine with 100 users. Then a promotional campaign drives 10x traffic, and it times out because the database was never indexed properly, no caching layer exists, and nobody load-tested it.

Why it matters: Technical debt accumulates like financial debt: shortcuts taken today cost more to fix later. Agencies that prioritize quick delivery over maintainability are building a house of cards. An agency that doesn’t ask about scalability, maintenance, or your future roadmap is not thinking beyond the invoice.

What to ask: “How have you designed this for scalability?” and “Have you load-tested for our expected traffic?” Also ask them to explain a key technical decision they made and why. If they can’t articulate the trade-offs, you have a code factory, not a technical partner.

Contractual protection: Include a performance testing requirement in the scope. Define minimum performance thresholds (page load times, concurrent user capacity) as acceptance criteria. Require a post-launch performance review.

9. They treat your project as complete after launch

What it looks like: The agency disappears after deployment. A production bug affects customer transactions for days because post-launch support was never defined. There’s no monitoring, no alerting, no roadmap for improvements.

Why it matters: Launch is the beginning of your software’s real life, not the end of the project. The absence of post-launch support language in a proposal is one of the clearest indicators that the vendor hasn’t thought through the transition, and that’s exactly where you’ll be most exposed. Many agencies optimize for final payment, not long-term partnership.

What to ask: “What does your post-launch support include? What are your response times for critical issues? What’s the duration of the support window?” Vague promises of “ongoing support” without an SLA, response time commitment, or scope definition mean nothing.

Contractual protection: Require a minimum 30-day post-launch support window with defined severity levels and response SLAs. For example: critical bugs (site down, data loss) within four hours; standard issues within 24 hours. Define what’s included versus what’s billed separately.

ready when you are

Vetting a development partner?
Ask us the hard questions.