To evaluate a custom software development company, check their own technical output, call real client references, read the contract terms on IP and termination, and test their judgement with a paid discovery phase before you sign anything. The strongest signal is an agency that pushes back on your requirements instead of agreeing to everything you ask for.

Key takeaways

  • Judge agencies by their own technical output (site performance, code, writing), not their sales deck.
  • Compare engagement models on risk and control, not just headline price; fixed price often costs more once change orders start.
  • Budget for hidden costs: infrastructure, documentation, QA, and scope creep, not just the contract line.
  • Red flags include no access to the actual team, vague technical proposals, and agencies that never push back.
  • A short paid discovery phase is the cheapest way to test an agency's judgment before signing a full contract.

Updated 5 November 2026: sources added, experience claims checked against our project record, summary added.

How to Evaluate Custom Software Development Companies in 2026

Why Most Agency Evaluations Fail

Most companies choose a software partner on the strength of the best presentation. The agency with the slickest deck, the smoothest salesperson and the most impressive logo wall often wins. Three months in, the client finds that the senior architect from the pitch never touched the project. The real team is a rotating cast of juniors.

Companies evaluate in the wrong order. They often spend more time judging the pitch than judging actual skill. It should be the other way round.

The sales team's job is to close deals. That isn't cynical, it's how the business works. But the people you meet in sales often aren't the people who build your software. Sales engineers can be skilled, but when they cover dozens of accounts, projects often get staffed with whoever's free.

The Bait-and-Switch Problem

Client reviews on platforms like Clutch often describe a gap between the pitched team and the team that turns up. It's one of the most common complaints about outsourced development, and it points to a systemic problem, not a few bad apples.

The fix isn't to avoid agencies. It's to judge them differently.

What to Look for Before the First Call

Before you book a discovery call, you can learn a lot from public information.

Their Own Website and Tech Stack

People often skip this step. If you're hiring a company to build modern web software, check their own site first. Is it fast? Is it well built? You can check Lighthouse scores in Chrome DevTools in under a minute.

An agency that specialises in Next.js development but runs its own site on a bloated theme with a poor score is telling you something. This site runs on Astro 5 and Supabase, the same tools we recommend to clients. An agency's own stack is the easiest thing to verify.

Open Source Contributions and Technical Writing

Check their GitHub and their blog. Are real engineers writing real technical content, or is it all generic marketing copy? Technical depth in public content is among the strongest signs of real skill.

Case Studies with Substance

Good case studies include:

  • The actual problem, not just "they needed a website"
  • Technical decisions and why they were made
  • Measurable outcomes (load time improvements, conversion rates, cost savings)
  • The stack used and why

A case study worth trusting shows a real before-and-after, such as a WordPress-to-Next.js migration that took a site's Lighthouse score from 35 to 94, with the stack, timeline and outcome spelled out. Bad case studies are just screenshots and testimonials. Screenshots prove nothing.

Client Retention Rate

Ask directly: "What percentage of your clients come back for more work?" A healthy agency should see many clients return. If they can't answer at all, that tells you something too.

Engagement Models Explained Honestly

Every agency presents its engagement models as if it invented them. There are only a few structures, and each has real trade-offs.

Model Best For Risk Level Budget Predictability Your Control
Fixed Price Well-defined scope, smaller projects Low (if scope is truly fixed) High Low
Time & Materials Evolving requirements, longer projects Medium Low High
Dedicated Team Ongoing development, product companies Medium Medium High
Retainer Maintenance, iterative improvements Low High Medium
Outcome-Based Clear business metrics, brave agencies High (for agency) Variable Low

Fixed Price: The Comfortable Lie

Fixed price feels safe because you know what you'll pay. In practice, the agency pads the estimate to cover risk, sometimes heavily. Then, when scope creeps (and it always does), change orders cost more than the padding would have. Clients often end up paying more than time-and-materials would have cost, plus the hassle of negotiating every change.

Fixed price works for genuinely well-defined projects. A marketing site with clear designs, a known CMS and no custom backend logic is a good fit. A complex web app with user logins, third-party tools and shifting requirements is not. Fixing the price for that is wishful thinking.

Time & Materials: Honest But Scary

T&M gets a bad reputation because it feels like writing a blank cheque. It's actually the most honest model, since you pay for exactly what you get. The key is governance: weekly budget reviews, burn rate tracking, and the ability to adjust priorities.

Good agencies give a T&M estimate with a confidence range: "We think this is 400-500 hours, and here's how we got there." That's honest. "It'll take as long as it takes" is not.

Dedicated Team: The Sweet Spot for Product Companies

If you're building a product and need ongoing work, a dedicated team makes sense. You get consistent people who learn your domain. It's staff augmentation with more structure.

The trap is paying for a full team when you only need half of one. Make sure the team size can flex. If an agency requires a minimum of 5 developers and you only need 2-3 most of the time, walk away.

How to Evaluate Custom Software Development Companies in 2026 - architecture

Pricing: What Things Actually Cost in 2026

Rates vary a lot by region and seniority, and agencies rarely publish them. It helps to know the shape of the market before a call.

Hourly Rates by Region (2026)

Region Junior Dev Mid-Level Dev Senior Dev Tech Lead/Architect
US (Top Tier) High Higher Highest Highest
US (Mid Market) Moderate-high High Higher Highest
Western Europe Moderate-high High Higher Highest
Eastern Europe Low-moderate Moderate Moderate-high High
Latin America Low-moderate Moderate Moderate-high High
South/Southeast Asia Lowest Low Moderate Moderate-high

These are relative bands for blended, client-facing rates, not developer salaries. The agency's margin sits on top of what the developer actually earns, and it can be large.

Project Cost Ranges

For context on what projects typically cost in 2026:

  • Marketing website (headless CMS, modern framework like Astro or Next.js): low five figures to the lower end of six figures, depending on complexity
  • E-commerce site (headless, custom): solidly into six figures for most custom builds
  • Web application (SaaS MVP): six figures, often toward the higher end depending on scope
  • Enterprise application: well into six figures, sometimes seven
  • Headless CMS migration (from a monolithic platform): mid five to low six figures

If a quote comes in far under these bands, either the team is offshore, cutting corners, or doesn't understand the scope. If a quote comes in far over, make sure the premium is justified. Our pricing page shows how we handle this openly.

Hidden Costs That Will Wreck Your Budget

The sticker price is never the full price. Here's where the hidden costs hide.

Infrastructure and Third-Party Services

The agency builds the product, but who pays for hosting, CDN, CMS licences, monitoring tools, CI/CD pipelines and error tracking? Depending on scale, these can add a recurring cost of anything from a few hundred dollars a month to several thousand. Get this itemised upfront.

## Example monthly infrastructure costs for a mid-size web app
Vercel Pro:                    $20/month
Supabase (database + auth):    $25/month
Sanity CMS (team plan):        $99/month
Cloudflare Pro:                $20/month
Error tracking tool:           ~$25/month
GitHub Team:                   $4/user/month
Monitoring platform:           ~$25/month
---
Total:                         ~$250/month minimum

Current list prices for these tools are on Vercel, Supabase, Sanity, Cloudflare and GitHub. They change often, so check before you budget.

That's a simple setup. Enterprise apps running on AWS can reach several thousand dollars a month or more.

Knowledge Transfer and Documentation

When the project ends, can your internal team, or a different agency, maintain the code? If the code isn't documented, if there's no record of key decisions, or if the deployment process lives in one person's head, you're stuck. Unwinding that lock-in is expensive. Companies sometimes pay large sums just to have a new team understand and document a codebase the original agency left undocumented. Make documentation a deliverable, not an afterthought.

The "Just One More Thing" Tax

Agencies love it when you say "can we just add..." during a fixed-price project. Each "just" becomes a change order. By the end, your $80,000 project is $140,000 and everyone's frustrated. The fix: build in a contingency budget from day one and stay disciplined about scope.

Testing and QA

Some agencies leave testing out of their estimates. They build features, let you find the bugs, then bill you to fix them. Always ask: "What does your testing process look like, and is it included in the estimate?"

Good agencies include:

  • Unit tests (meaningful coverage for critical paths)
  • Integration tests
  • End-to-end tests for critical user flows
  • Cross-browser testing
  • Accessibility testing against WCAG 2.1 AA as a minimum bar

Red Flags That Should Kill the Deal

These patterns show up again and again in teams that got burned by a vendor. Any one of them should make you pause.

🚩 They Can't Show You the Actual Team

If you can't meet the developers who'll work on your project (even by video) before signing, run. "We'll assign the right people" means they don't know yet, which means they'll assign whoever's free when your project starts.

🚩 No Technical Person in the Sales Process

If every call is with account managers and project managers and you never talk to an engineer, the agency values sales over engineering. The best agencies bring senior engineers into scoping and estimation.

🚩 They Say Yes to Everything

A good agency pushes back. "That feature doesn't make sense for your users." "That timeline is unrealistic, and here's why." "You don't need a custom solution for this, use an off-the-shelf tool." An agency that agrees with everything is optimising for closing the deal, not for your success.

🚩 Vague or Missing Technical Proposals

The proposal should spell out:

  • Architecture approach
  • Technology choices and why
  • Third-party services involved
  • Performance targets
  • Security considerations
  • Deployment strategy

If it just says "we'll build a React application" with no further detail, they haven't thought about your project.

🚩 They Own the Code or IP

This is common and never acceptable for custom development. You're paying for it, so you own it. Read the contract closely. Some agencies keep IP rights to "reusable components," a term defined so broadly it can mean they effectively own your codebase.

🚩 No Defined Process for Handling Disagreements

Every project hits rough patches. What happens when there's a dispute about scope? What's the escalation path? If the answer is "we'll figure it out," you'll be figuring it out with lawyers.

Green Flags That Actually Mean Something

✅ They Tell You What You Don't Need

The strongest agency relationships often start with the agency pushing back. A good example: "You don't need half of what's in your RFP. Here's what you actually need, and it will likely cost less." That kind of honesty builds trust fast and often saves real budget.

✅ They Have a Specific Niche

An agency that does "everything," mobile, web, AI, blockchain, IoT, is a generalist. Generalists work fine for simple projects. For anything complex, you want specialists. If you're building a headless web app, you want an agency that does headless CMS development as a core skill, not as one of dozens of services on a list.

✅ They Share Their Process in Detail

Not just "we're agile" (everyone says that). Ask for specifics: sprint cadence, how they handle code reviews, their CI/CD setup, how they manage technical debt, their testing plan, and how they report progress.

✅ References You Can Actually Call

Not testimonial quotes on their website. Ask for real people you can call or email who will tell you what it was really like to work with them. Ask references these questions:

  • Did the project come in on time and budget?
  • What went wrong and how was it handled?
  • Would you hire them again?
  • Was the team stable throughout the project?

How to Run a Proper Evaluation Process

Here's a process that works well for vetting vendors.

Step 1: Define Your Requirements Before Talking to Anyone

Write down what you need. Not how to build it, but what the business outcome should be. If you define the solution before talking to experts, you'll miss better approaches.

Step 2: Create a Shortlist of 3-5 Candidates

More than 5 and you'll drown in proposals. Fewer than 3 and you won't have enough to compare. Use the "before the first call" checklist above to narrow the field.

Step 3: Paid Discovery or Technical Assessment

The best signal is watching an agency actually work. Many good agencies offer a paid discovery phase: a week or two in which they examine your requirements and produce a technical plan. It usually costs a small fraction of the full project and is money well spent.

Some companies run a small paid pilot project instead. Even better. Nothing reveals skill like real output.

Step 4: Evaluate the Plan, Not Just the Price

When proposals come back, don't jump straight to the bottom line. Read the technical approach. Does it show real understanding of your problem? Are the assumptions stated clearly? Is there a risk section?

Step 5: Check the Contract Carefully

Key things to verify:

  • IP ownership (should be yours)
  • Termination clause (30 days notice is common)
  • Payment terms (never pay 100% upfront; milestone-based is ideal)
  • Warranty period (30-90 days post-launch for bug fixes)
  • Source code access (you should have it throughout, not just at the end)

The Technical Due Diligence Checklist

If you have a technical person on your team, have them check these specifics:

## Technical Evaluation Criteria

### Code Quality
- [ ] Ask to see a code sample (anonymized from a past project)
- [ ] Check for consistent coding standards
- [ ] Look for test coverage
- [ ] Evaluate commit history practices (meaningful commits, not "fixed stuff")

### Architecture
- [ ] Can they explain their architecture decisions and trade-offs?
- [ ] Do they consider scalability from the start?
- [ ] Is their approach to state management sensible?
- [ ] How do they handle data modeling?

### DevOps & Deployment
- [ ] Automated CI/CD pipelines
- [ ] Infrastructure as Code (Terraform, Pulumi, etc.)
- [ ] Environment parity (dev/staging/production)
- [ ] Monitoring and alerting strategy

### Security
- [ ] OWASP Top 10 awareness
- [ ] Authentication/authorization approach
- [ ] Data encryption practices
- [ ] Dependency vulnerability scanning

If you don't have a technical person, hiring a fractional CTO or technical advisor for a few hours can save you from a costly bad decision.

FAQ

How much should I budget for a custom software development project?

Budget well above average for a meaningful custom web app MVP built by a US-based or Western European agency, since offshore rates run well below onshore rates for comparable scope. Add a solid contingency on top of any estimate, since most projects grow once development starts.

Offshore savings come with more communication overhead and more risk of uneven quality, so weigh both against the lower price. If your budget is tight, you're likely better served by a no-code platform or a narrow, single-feature build than by a full custom app.

Should I hire an offshore development company to save money?

Yes, if you have a strong technical lead in-house who can review code and give clear direction. The savings can be large, but without in-house oversight, offshore work tends to underperform and produce code nobody can maintain.

Offshore works poorly when the offshore team owns both architecture and implementation. Working across time zones, language gaps and different communication norms carries real overhead, so weigh that against the rate savings before committing.

What's the difference between a software development agency and freelancers?

Agencies give you a team with built-in backup, set processes and usually a broader skill set, at a clearly higher cost than freelancers. Freelancers suit short, well-scoped projects with a clear deliverable; agencies suit anything longer, larger or more complex.

If a freelance lead developer gets sick or quits, the project stops. With an agency, someone else can pick up the work. For anything beyond a short, well-defined job, an agency's structure usually pays for itself.

How do I know if an agency is actually good at what they claim?

Check three things: their own technical output, such as site performance, open source work and blog posts; real client references you can actually contact; and their willingness to run a paid technical assessment before a full contract. Any agency that can't offer all three deserves a closer look.

Also ask them to walk you through a past project that went wrong and how they handled it. An agency that claims every project went perfectly is either lying or hasn't done enough projects.

What contract terms should I insist on with a development company?

Insist on five things before signing: you own all IP and source code outright, you get ongoing access to the repository during the project, a 30-day termination clause, milestone-based rather than upfront payment, and a warranty period of at least 60 days for bug fixes after launch.

Also insist on a clear definition of "done" for each milestone and a documented change request process with pre-agreed rates.

How long does custom software development typically take?

A marketing website built on a headless CMS typically takes a few weeks. A web app MVP usually takes several months, a full SaaS platform can take most of a year, and enterprise apps often run well past a year from discovery to launch.

Any agency that promises a complex app in 4 weeks is either badly underestimating the scope or planning to deliver something half-baked. Be very sceptical of tight timelines. They almost always lead to cut corners.

What questions should I ask during the first call with a development agency?

Ask four direct questions: "Who specifically would work on my project, and can I meet them?" "Show me a project that failed or went over budget, what happened?" "What would you push back on in my requirements?" and "How do you handle it when we disagree on a technical approach?"

Skip the softballs. How well they answer hard questions tells you more than any polished case study.

Is it worth paying for a discovery phase before committing to full development?

Yes. A modest paid discovery phase can save far more in wasted development time than it costs, by testing assumptions, surfacing technical risks and producing a realistic plan before a full contract is signed. Skipping it is a false saving.

Discovery also gives you a low-risk way to see how an agency actually works before a bigger commitment. If an agency won't do paid discovery and insists on a full contract right away, treat that as a red flag. If you want to see what a proper discovery process looks like, reach out to us.