What to evaluate in a software development agency
Most teams choose an agency on price and gut feel, then spend the next six months regretting it. A better approach is to evaluate every candidate against the same fixed set of criteria. Here are the seven that actually predict whether an engagement succeeds.
1. Portfolio and case studies
Anyone can show a deck. What matters is shipped software you can open and use, ideally in a space adjacent to yours. Ask for two or three case studies with the problem, the agency's specific role, the stack, and a measurable outcome — users, revenue, load times, conversion. Then ask to speak to those clients. The best signal is a reference call that confirms the agency stayed reliable after the contract was signed.
2. Technical expertise
Get the engineers on the call, not just sales. You want depth in your actual stack — not a logo wall of thirty technologies. Public code, open-source contributions, or engineering writing are strong proof. Ask how they'd architect your specific problem and listen for trade-offs rather than buzzwords. If you're weighing technology choices, our framework comparisons are a good place to pressure-test their reasoning.
3. Communication
Communication during the sales process is the best preview you'll get of the working relationship — and it only gets slower after the contract. Look for fast, clear replies, a named point of contact, enough timezone overlap to work in real time, and proactive updates before you have to chase them.
4. Process
"We're agile" means nothing without artifacts. A credible agency runs defined sprints, shows you working software in regular demos, reviews its own code, runs CI/CD, and can point to a written definition of done. Ask to see a sample sprint board or a past project's cadence. A clear process is what keeps a build on track when scope inevitably shifts.
5. Pricing model
The right model depends on how stable your scope is. Use time-and-materials (T&M) for evolving products where requirements will change — you keep flexibility and full visibility, often with a not-to-exceed cap. Use fixed-price only when the scope is genuinely complete and stable, since every change after sign-off becomes a change order. Whichever you choose, insist on a transparent rate card and a real estimate.
6. IP and ownership
You should own everything the agency builds — source code, designs, and all third-party accounts — and the contract has to say so explicitly, with assignment on payment and repository access from day one. Confirm hosting, domains, and cloud accounts are registered in your name. If an agency keeps code on its own servers or offers a license instead of ownership, walk away.
7. Post-launch support
Launch is the start of the product's life, not the end. Production software needs bug fixes, security patches, and iteration. A serious partner offers a defined maintenance plan, a documented handover, and an SLA for critical issues. See how we think about this in our maintenance and support approach.
Evaluation criteria at a glance
Use this as a scorecard across your shortlist. For each criterion, note what a strong answer looks like — and the signal that should make you pause.
| Criterion | What to look for | When to walk away |
|---|---|---|
| Portfolio & case studies | Shipped products you can open, with measurable outcomes (users, revenue, performance) and a named role in the work. | Only mockups, dead demo links, or NDA-everything with nothing verifiable. |
| Technical expertise | Depth in your actual stack, public code or engineering writing, and engineers (not just account managers) on the call. | A logo wall of 30 technologies and vague 'full-stack' claims with no specifics. |
| Communication | Fast, clear replies; a named point of contact; timezone overlap; and proactive updates before you ask. | Slow or templated responses during the sales process — it only gets slower after the contract. |
| Process | Defined sprints, demos, code review, CI/CD, and a written definition of done you can inspect. | 'We're agile' with no artifacts — no board, no demos, no test coverage commitment. |
| Pricing model | A model that fits your scope risk (T&M for evolving products, fixed for tightly-specced builds) with a transparent rate card. | A suspiciously low fixed quote on a fuzzy spec, or hourly rates with no cap or estimate. |
| IP & ownership | A contract that assigns all source code, accounts, and IP to you on payment, with full repo access from day one. | Code kept on the agency's servers, 'license' instead of ownership, or hostage hosting accounts. |
| Post-launch support | A clear maintenance plan, documented handover, and an SLA for bugs and security patches. | 'Project ends at launch' with no warranty period and no plan for the inevitable production issues. |
Questions to ask before hiring
Strong agencies answer all of these concretely — and in writing. Vague or evasive answers are themselves the answer.
- Can I see two products you shipped in my space, and talk to those clients?
- Which specific engineers will work on my project, and what's their experience?
- How do you handle scope changes, and which pricing model do you recommend for my project — and why?
- Who owns the code, designs, and accounts? Is IP assignment in the contract?
- What does a typical week look like — sprints, demos, code review, testing, deployment?
- What happens after launch? What's the warranty period and the ongoing support plan?
- What's your estimate for my scope, and what would make it go over?
Red flags to watch for
Any single one of these warrants more questions. Two or more is usually a reason to keep looking.
- A price far below the rest of your shortlist with no scope detail — the gap is almost always cut corners or change-order surprises later.
- No verifiable portfolio: only mockups, dead links, or NDA-everything with nothing you can open.
- Slow, templated, or vague communication during the sales stage.
- Reluctance to put IP ownership and code access in writing.
- No defined process, no testing commitment, and no demos.
- A single point of failure — one developer doing design, frontend, backend, and DevOps alone.
- High-pressure tactics: 'sign today or the price goes up.'
Agency vs. freelancer vs. in-house
The right model depends on the size of the job and whether software is your core product:
Freelancer
Best for small, well-defined tasks needing one skill set — fast and cost-efficient. Weak when the work spans design, backend, and QA, or when one person becomes a single point of failure.
Agency
A cross-functional team — design, frontend, backend, QA, DevOps — that ships a real product on a deadline, without the cost and risk of hiring. Best when you need to launch something substantial reliably.
In-house
The right call when software is your core product and you can commit to a permanent engineering team. Highest control and long-term ownership, but the slowest and most expensive to stand up.
Many teams blend these: an agency builds and launches, then trains or hands over to an in-house team — or supplies a dedicated team that works as an extension of yours. For a deeper breakdown of the trade-offs, read in-house vs. outsourced development.
A short evaluation checklist
Before you sign, confirm you can tick every box:
- You've seen two or more shipped products and spoken to at least one reference.
- The engineers who will build your project were on the call.
- Communication has been fast and clear throughout the sales process.
- There's a documented process: sprints, demos, code review, testing, CI/CD.
- The pricing model fits your scope, with a transparent rate card and an estimate.
- The contract assigns all IP and source code to you, with repo access from day one.
- There's a written post-launch support plan and warranty period.
- You can start with a small paid pilot before the full engagement.