What are the red flags when hiring a software development agency?

Most founders only recognize a bad agency after the damage is done, after the missed deadline, the ballooning invoice, or the moment they realize the code they paid for cannot be transferred to anyone else. By that point, the sunk cost is real and the options are painful.

The warning signs exist before any contract is signed. They show up in sales calls, in how quickly emails get returned, and in what an agency will and will not put in writing. Knowing where to look changes the outcome entirely.

The way an agency communicates before you become a client is the most accurate preview of how they will communicate once you are one. Agencies do not suddenly become more organized or more responsive after the contract is signed. If anything, the attention gets thinner.

A 2021 PMI report found that poor communication is a contributing factor in 29% of failed projects, ranking ahead of both unclear requirements and budget issues. The pattern tends to follow a consistent shape: slow pre-sales replies turn into slow status updates, which turn into slow responses when something breaks.

The specific signals to watch: responses that take more than 24 hours during the sales process, meetings that produce no written summary or next steps, and any tendency to give verbal commitments that never make it into documentation. When you ask a specific question, "What does your QA process look like?" or "Who will be my main point of contact?", and the answer is vague or deferred, that is not a coincidence. That answer is the answer.

Good agencies have rehearsed, specific answers to these questions because they have done it many times. They can tell you the name of your project manager before you sign, describe their weekly update format, and explain what happens when a deadline slips. If the agency cannot describe their own process clearly to a prospective client, the build will reflect that same lack of structure.

Two pricing problems consistently produce the same outcome: a bill far larger than anyone agreed to.

A wide, vague estimate is often the earliest warning sign. A range like "$20,000 to $80,000 depending on scope" is not a quote; it is a way of avoiding commitment. A Western agency quoting that range for a mid-complexity product is telling you they have not thought carefully about your project, or they are leaving themselves room to bill toward the top when scope expands. A credible agency quotes a narrow range with a specific anchor because they have scoped the work. "Around $35,000, possibly $38,000 if the payment integration runs long" is a quote. "Anywhere from $20,000 to $80,000" is not.

The second problem is time-and-materials billing without a scope ceiling. This arrangement charges you for every hour worked, with no cap. It sounds flexible but functions as a blank check. A 2022 Standish Group report found that software projects without fixed scope definitions run over budget 66% of the time, often by 20–50%. The agency's financial incentive under time-and-materials is misaligned with yours: more hours means more revenue for them.

The ask that separates serious agencies from risky ones: request a fixed-price quote with a detailed scope document before signing. Every feature you are paying for should be named and described. Any agency that refuses to commit to fixed pricing for a well-defined scope is signaling that they expect the scope to grow, and that they plan to bill you for it.

The source code is the product. When a software agency builds something for you, the output is code: files that live on a server and power everything your users see and do. If you cannot access that code freely, you do not fully own what you paid for.

Some agencies default to hosting client code in their own accounts, with access granted only during the engagement. Others delay handing over repositories until final payment clears, sometimes months after the work was completed. A smaller number use proprietary frameworks or custom infrastructure that only they know how to operate, making it economically painful to leave.

Each of these patterns creates the same outcome: the agency controls your exit. If the relationship sours, if they raise prices, if the team changes and quality drops, your ability to walk away depends on their cooperation rather than your own rights.

Before signing, confirm three things in writing. You should have access to the full source code repository from day one of the build, not just at project completion. The codebase should be built with standard tools that any developer can work with, not a custom framework that requires the original team. And all accounts, hosting, domain, third-party services, should be registered in your name, not the agency's.

A 2019 survey by the Software Equity Group found that 34% of founders who had worked with external development firms reported difficulty transferring their codebase to a new team. In most cases, the problem was not technical complexity. It was structural lock-in that had been built into the engagement from the start.

A software build is not a factory line where one worker can replace another without consequence. The developer working on your project carries context: how your features connect, why certain decisions were made, where the edge cases live. When that developer rotates off mid-build and someone new steps in, that context does not transfer automatically. It gets partially reconstructed, partially guessed at, and partially lost.

Agencies that rotate developers frequently do so for legitimate internal reasons: other projects, staffing flexibility, resource optimization across their portfolio. The problem is that you absorb the cost. Each handoff adds one to two weeks of ramp-up time, during which the new developer is learning rather than building. On a three-month project, two developer rotations can consume 20–30% of the available timeline without producing a single deliverable.

The visible symptoms are subtle at first: inconsistencies in how different parts of the app work, bugs in areas that were previously stable, and a project manager who struggles to give specific answers about feature status. By the time a founder recognizes the pattern, the project is usually behind schedule.

Ask directly before signing: will the same senior developer work on my project from start to finish? Get the answer in the contract, not just the sales call. A credible agency will either commit to named developers or explain their staffing model honestly. An agency that deflects this question has already answered it.

Before you start, not after. Once development has begun and money has changed hands, the decision to leave gets harder with each passing week, not because the situation improves, but because the sunk cost grows. The point where walking away costs the least, financially and operationally, is before the first invoice.

That said, there are moments during a build where the pattern becomes undeniable and continuing is clearly worse than stopping. The clearest is when deliverables have been missed by two or more consecutive milestones without a credible recovery plan. A single missed deadline can be circumstantial. Two in a row with vague explanations is a pattern.

The second moment is when access to your own assets gets restricted. If an agency has deployed your product to their hosting account, written the code in their repository, or registered your domain in their company name, your ability to leave is already compromised. Moving at that point requires either their cooperation or a legal process. Neither is fast.

Practically, the safest approach is to treat each milestone as an independent decision point. At every delivery, ask whether you would hire this team again given what you have seen so far. If the honest answer is no, and the pattern from earlier milestones suggests it will not improve, the decision to stop is easier before the next payment than after.

Timespade structures every engagement around fixed milestones tied to specific deliverables, with source code and all accounts in your name from day one. No lock-in, no developer rotation without your knowledge, no quote that expands by 60% mid-build. A full team (project manager, designer, senior engineers, QA) for $5,000–$8,000 per month, with delivery timelines that most Western agencies quote at three to four times the price.

If you are evaluating agencies right now and want a second opinion on a scope or a quote, Book a free discovery call.