Warning signs that a development agency will waste your money and time. Learn what to watch for before you sign the contract, not after.
January 22, 2025 9 min read
Most founders learn to recognize bad agencies the hard way: after thousands of dollars and months of frustration. The warning signs were there from the beginning. They just didn't know what to look for.
This guide covers the red flags that predict agency failures. Some are obvious in hindsight. Others are subtle enough that even experienced founders miss them. None of them guarantee disaster, but each should trigger deeper investigation before you commit.
Red Flags During Sales
The sales process tells you a lot about how an agency operates.
Quoting Without Discovery
Any agency that gives you a fixed price and timeline after a single call is either:
Selling a templated product (which might be fine, but you should know that)
Guessing (which is not fine)
Complex software requires understanding before estimating. If they're confident after hearing a 10-minute pitch, they're either not building something custom or not being honest about the uncertainty.
What good looks like: A discovery phase—paid or unpaid—before committing to scope, price, and timeline. Documentation of what will be built before work begins.
Refusing to Share Who'll Work on Your Project
"We have a great team" is not the same as "Sarah and Marcus will be building your product, here's their background."
Some agencies staff projects with whoever's available. The impressive people in the sales meeting may never touch your code. If they won't tell you who's working on your project, that's deliberate opacity.
What good looks like: Named team members with relevant experience. Ability to interview or at least meet them before commitment.
Stop planning and start building. We turn your idea into a production-ready product in 6-8 weeks.
Pressure to Sign Quickly
"This price is only good until Friday"
"We have limited availability and need an answer now"
"We're filling up our next quarter fast"
Urgency tactics signal desperation or manipulative sales practices. Good agencies have waitlists because they do good work, not because they pressure clients into fast decisions.
What good looks like: Clear timeline for decision, willingness to answer questions, no artificial urgency.
Vague or Evasive About Process
Ask: "Walk me through how you work with clients."
If the answer is vague—"We follow agile" without specifics—they either don't have a real process or don't want to explain it.
What good looks like: Clear explanation of communication cadence, milestone structure, demo schedule, feedback process, and deployment approach.
Can't Explain Past Projects in Detail
Ask about a similar project they've built. If they can't explain:
What challenges they encountered
How they solved them
What they learned
...they either didn't do meaningful work on that project or don't learn from their experience.
What good looks like: Detailed case studies with specific challenges, decisions, and outcomes.
Red Flags in Contracts
Contracts reveal priorities. Read carefully.
Hourly Billing Without Caps
Pure hourly billing with no cap or estimate creates misaligned incentives. The longer the project takes, the more they earn. Your goals (done, fast, within budget) and their goals (maximize billable hours) conflict.
What good looks like: Fixed pricing, or hourly with clear estimates and caps, or milestones with defined deliverables.
Ownership Ambiguity
You should own your code. Completely. Including:
All source code
All designs and assets
All documentation
All third-party credentials and accounts
If the contract includes any retention of IP rights, that's a red flag. You're paying for work product; you should own it.
What good looks like: Explicit assignment of all intellectual property to you upon payment.
No Defined Milestones
"We'll build your MVP" without interim checkpoints is a recipe for disaster. You need visibility into progress throughout, not just at the end.
What good looks like: Defined milestones with specific deliverables, payment tied to milestone completion, regular demos showing progress.
Aggressive Payment Terms
100% upfront is a red flag. 50% upfront, 50% on completion with no interim visibility is also concerning.
What good looks like: Payment tied to milestones—some upfront, more at interim checkpoints, final on delivery and acceptance.
Punitive Change Terms
Change happens in software development. Contracts that penalize any change or make modifications prohibitively expensive signal inflexibility.
What good looks like: Clear change request process with reasonable pricing for modifications, not designed to punish normal scope evolution.
Red Flags During the Project
Once work begins, new warning signs emerge.
Radio Silence
You should hear from your agency regularly. If you have to chase updates, that's a problem. Silence usually means either nothing is happening or something is wrong that they don't want to share.
What good looks like: Proactive weekly updates, regular demo sessions, quick responses to questions.
No Working Software Until the End
If weeks pass without seeing working software, you're in trouble. Agencies can write specifications, create designs, and "set up infrastructure" indefinitely without producing anything real.
What good looks like: Visible progress within the first two weeks. Working features—even basic ones—by week three or four.
Blaming Tools or Third Parties
Problems happen in software development. How agencies respond matters.
"The API documentation was wrong" or "The design tool caused issues" or "We're waiting on [external dependency]" becomes a pattern with some agencies. Good teams solve problems; weak teams explain why problems aren't their fault.
What good looks like: Ownership of problems. "We hit an issue with X. Here's what we tried, here's what we're doing, here's the impact on timeline."
Constant Scope Negotiation
Every demo becoming a negotiation about what's in scope vs. out of scope indicates misaligned expectations. Either the initial spec was unclear or the agency is looking for reasons to bill more.
What good looks like: Demos focused on what was delivered, clear acknowledgment of what's next, scope discussions reserved for actual changes.
Revolving Door of Personnel
If your point of contact changes, or the developers on your project change, that's concerning. It suggests either poor retention or deliberate bait-and-switch.
What good looks like: Stable team throughout the engagement. If changes happen, honest explanation of why.
Defensive Response to Feedback
When you provide feedback:
Do they incorporate it?
Do they explain trade-offs?
Or do they push back on everything?
Agencies that treat every feedback item as a battle signal problems ahead. You're the client. Your feedback matters.
What good looks like: Thoughtful engagement with feedback. Pushback when genuinely warranted, with explanation.
Red Flags in Deliverables
The work product itself reveals quality.
No Documentation
If you receive code without documentation, you'll struggle to maintain or extend it. Documentation isn't a nice-to-have—it's part of professional delivery.
What good looks like: README files, architecture documentation, deployment procedures, code comments on complex sections.
No Source Control History
You should receive a complete git history, not just a zip file of final code. The history shows how the project evolved and helps future developers understand decisions.
What good looks like: Access to the git repository with complete commit history.
Can't Deploy Without Them
If the agency set up infrastructure you don't have access to, or processes you can't run, you're dependent on them for every change. That's either incompetence or intentional lock-in.
What good looks like: All credentials, all infrastructure access, all deployment procedures documented and transferred.
Obvious Quality Issues
Pages that crash on load
Features that don't work as specified
UI that doesn't match approved designs
Performance so slow it's unusable
These aren't "bugs to fix later." They indicate fundamental quality problems.
What good looks like: Working software that matches specifications, with bugs being edge cases rather than core functionality.
Meta Red Flags
Some warning signs transcend specific situations.
Your Gut Says Something's Wrong
If you feel uneasy about the engagement but can't articulate why, investigate that feeling. Experienced founders develop instincts for bad partnerships. Don't ignore yours.
They've Never Said No
An agency that agrees to everything you suggest might be telling you what you want to hear rather than what's true. Good partners push back when you're wrong.
Communication Feels Like Work
If every interaction is frustrating, if you dread calls, if getting straight answers feels like pulling teeth—trust that signal. Communication difficulty usually gets worse, not better.
You're Doing Their Job
If you're project managing, reminding them of deadlines, catching their mistakes, and coordinating their work—you're paying for services you're providing yourself.
What to Do When You See Red Flags
Before Signing
Walk away. There are other agencies. The red flags you see now will only multiply during the project.
Early in the Project
Address directly. "I've noticed [specific issue]. Can we discuss how to fix this?" Some problems are miscommunication and can be resolved.
Deep Into the Project
Assess honestly:
Is this salvageable?
What's the cost of switching vs. continuing?
Are they willing and able to improve?
Sometimes cutting losses earlier is better than throwing good money after bad.
Can I speak with a recent client whose project was similar to mine?
What does your typical week with a client look like?
How do you handle scope changes?
Show me a detailed case study of a similar project.
What happens if we need to part ways mid-project?
Walk me through how you handle quality assurance.
Who owns the code and when?
Evasive or vague answers to these questions are themselves red flags.
Key Takeaways
Red flags during hiring predict red flags during projects.
Sales red flags:
Quoting without discovery
Hiding who works on your project
Pressure to sign quickly
Vague about process
Can't explain past work in detail
Contract red flags:
Hourly without caps
Ownership ambiguity
No defined milestones
Punitive change terms
Project red flags:
Radio silence
No working software
Blaming external factors
Constant scope negotiation
Revolving team members
Deliverable red flags:
No documentation
No source control history
Can't deploy without them
Obvious quality issues
Trust your instincts. If something feels wrong, it probably is. The best time to recognize red flags is before you sign the contract, not after you've invested months and thousands of dollars. For an alternative comparison, see agency vs. freelancer: when each makes sense.
At NextBuild, we operate transparently: named team members, fixed pricing, weekly updates, and full code ownership from day one. If you've seen too many red flags elsewhere, let's talk about doing this differently.
Learn how to create a basic version of your product for your new business.
