Choosing a software development company is one of the most consequential decisions a UK business makes. Get it right and you have a technical partner that delivers working software on time, communicates transparently, and becomes more valuable as your relationship deepens. Get it wrong and you face missed deadlines, budget overruns, technical debt that costs more to fix than to rebuild, and the uniquely dispiriting experience of paying £100,000+ for software that does not work properly.
The problem is that it is genuinely difficult to evaluate a software agency before you have worked with them. Portfolios are curated, references are pre-selected, and sales conversations are optimised to reduce your anxiety rather than give you accurate information. This guide gives you 10 specific questions — and exactly what good answers look like versus red flags — so you can make a properly informed decision.
Why Choosing the Wrong Agency Is So Expensive
A failed software project does not just cost the project budget. The real costs are:
- Direct budget loss: Deposits and milestone payments to the failed agency that cannot be recovered
- Rebuild cost: Fixing poor code is typically 2–5x more expensive than building it correctly the first time
- Opportunity cost: The market window, competitive advantage, or internal efficiency gain you were targeting with the software, delayed by 6–18 months
- Management time: A failing project consumes disproportionate senior time — escalations, status meetings, dispute resolution
- Team morale: Failed technology projects demoralise the teams that were expecting new tools
The 10 questions below are designed to surface these risks before you sign, not after you are committed.
Question 1: "Walk me through your discovery process."
Discovery is the phase before development begins — requirements gathering, technical architecture planning, UX research, scope definition. How an agency approaches discovery tells you more about their process maturity than anything else.
What a good answer looks like: A detailed description of a structured process: stakeholder workshops, user research, requirements documentation, architecture review, scope sign-off. A specific description of what deliverables discovery produces (PRD, wireframes, data model, technical specification). The agency should charge for discovery separately — it is real work.
Red flags: Discovery described as "a few calls to understand your requirements." No paid discovery phase — jumping directly to a full quote without understanding the project properly. Discovery described as part of the sales process rather than a separate, deliverable-producing engagement.
Question 2: "Can I speak to three past clients — including one where something went wrong?"
Every portfolio includes only successful projects. The most revealing reference is one where a challenge arose and you can ask how the agency handled it. No complex software project is entirely smooth — agencies with genuine experience have managed difficult moments.
What a good answer looks like: Willingness to provide references immediately. When you speak to references, listen for specifics: what was delivered, how communication worked when problems arose, whether the agency was transparent about issues, whether the final product matched what was sold.
Red flags: Reluctance to provide references, or only providing testimonials on their website rather than live contact with past clients. References who cannot describe the project in detail — often a sign of pre-coached answers. No references from projects that faced challenges.
Question 3: "Who will actually build my project — and what are their levels of experience?"
The sales team and the delivery team at many agencies are entirely different people. The senior developers who appear in sales presentations may rarely touch your project once it starts.
What a good answer looks like: A named team for your project before contract signing. Clear seniority levels — at minimum one senior developer involved throughout, not just at architecture review. A commitment to introduce you to your project team before signing.
Red flags: Vague answers about "our team" or "our developers." Unwillingness to commit to named team members before signing. Heavy reliance on junior developers supervised by a single senior who splits time across multiple projects. Agencies that heavily subcontract to freelancers without transparency about it.
Question 4: "How do you handle scope changes during development?"
Scope changes are inevitable in any non-trivial software project. How an agency manages them reveals their process maturity and whether they will protect you from budget shock or exploit changes to extract more money.
What a good answer looks like: A clear change request process: new requirements are documented, scoped, and priced before work begins. Transparency about the impact of changes on timeline and budget. A record of why changes were requested and approved. Regular scope review points that surface changes early before they become crises.
Red flags: "We're flexible, just tell us what you need" — no formal change process means no budget control. Fixed-price contracts with vague specifications, which either protect the agency at your expense (they descope to protect margin) or create dispute when you expect something the spec does not cover.
Question 5: "Show me the code for a completed project."
Most clients never ask to see the code — and agencies know this. Code quality is invisible to non-technical buyers until it causes problems. Asking to see the code (even if you cannot evaluate it yourself) signals that you take quality seriously, and the agency's response tells you a great deal.
What a good answer looks like: Willingness to share an anonymised codebase excerpt or, better, have a technical review done by an independent developer you bring in. Clean, well-commented code. Evidence of automated tests. Use of version control with meaningful commit messages.
Red flags: Flat refusal (understandable for confidential client code, but they should offer to arrange an NDA-protected review). Willingness to show code that, when reviewed by an independent developer, shows poor structure, no tests, and code that only the original developer could maintain.
Practical approach if you are non-technical: Hire a senior UK freelance developer for £600–£900 to review the code independently. This is one of the best due-diligence investments you can make before committing to a six-figure project.
Question 6: "How do you test your software?"
Testing is frequently the first thing cut when a project runs over budget or timeline. Agencies that genuinely invest in QA have a structured testing process they can describe in detail.
What a good answer looks like: Unit tests written alongside development code. Integration testing of API endpoints. End-to-end testing covering key user journeys. A dedicated QA person or process, not just developers testing their own code. UAT (user acceptance testing) with your team before launch. A defined bug severity system and SLA for fix timelines.
Red flags: Testing described as "developers review each other's code." No mention of automated tests. QA only described as something that happens "at the end" — by which point most testing budget has been consumed. No structured UAT process before sign-off.
Question 7: "What happens to the code and IP when the project is complete?"
This is a question many UK businesses do not ask — and discover the answer to at the worst possible moment. Intellectual property ownership, code repositories, and ongoing access are legal and practical questions that must be clarified before signing.
What a good answer looks like: A clear contract clause that assigns full IP ownership to the client upon payment of the agreed fees. Access to the code repository (Git) throughout the project, not just at completion. Assurance that you will have a deployable, working product at the end — not just source files that require the agency's tooling to run.
Red flags: Vague answers about IP. Contracts that only license the software rather than assigning ownership. Agencies that retain access to production servers or repositories after project completion. No handover documentation included in the project scope.
Question 8: "What contract structure do you offer — fixed price or time and materials?"
Both contract structures are legitimate, but the right choice depends on your project type and risk tolerance. Understanding the difference is essential for UK business owners engaging a software agency.
| Factor | Fixed Price | Time & Materials (T&M) |
|---|---|---|
| Budget certainty | High — you know the total cost | Low — cost depends on actual time spent |
| Scope flexibility | Low — changes require formal CRs | High — changes are natural |
| When to use | Well-specified, bounded projects | Exploratory, evolving, or complex projects |
| Agency risk management | Agency inflates estimates to protect margin | Client carries cost risk if project scope grows |
| Quality risk | Agency may cut quality to protect margin | No incentive to cut quality |
| Common in UK for | Well-defined integrations, fixed-feature MVPs | Product development, complex builds |
Practical recommendation: Fixed price works well when your specification is detailed and agreed, and you have the technical confidence to write a spec tight enough to prevent scope disputes. Time and materials is better when you expect to learn and iterate during the build. A hybrid approach — fixed price for discovery and design, T&M for development — is increasingly common and manages risk well for both parties.
Question 9: "How will you communicate with us during the project?"
Communication failure is cited in more failed software projects than any technical issue. Agreeing communication norms before starting — not assuming them — prevents the gradual disengagement that precedes project failure.
What a good answer looks like: A named project manager as your single point of contact. Scheduled weekly or biweekly project status calls with an agenda. A shared project management tool (Jira, Linear, Notion) where you can see progress and backlog in real time. A defined escalation path for issues. Sprint reviews or demo sessions to see working software regularly throughout the build — not just at the end.
Red flags: No named project manager. Communication by email only with no scheduled calls. No shared project tracking tool — status updates only when you ask. Demos only at project completion. Agencies that become difficult to reach once the contract is signed.
Question 10: "What UK-specific considerations do you bring to projects?"
Software development for UK businesses involves specific legal, compliance, and structural considerations that developers without UK market experience may miss.
What a good answer looks like (UK-specific factors to discuss):
- UK GDPR and data protection: How does the agency approach data architecture to ensure GDPR compliance from the design stage? Privacy by Design, data minimisation, data subject access request workflows, and right-to-erasure should be built in — not retrofitted.
- IR35 (if they use contractors): If the agency uses contractor developers on your project, who bears the IR35 liability? This should be clarified in the contract.
- Payment terms: UK commercial practice typically uses 30-day payment terms. Milestone payment schedules tied to deliverables protect you better than large upfront payments.
- UK-based support: For ongoing maintenance, UK business hours support is often worth paying a premium for. Offshore support creates timezone and communication delays at the worst possible moments.
- Companies House and Companies Act compliance: For software handling company financial data or regulated activities, awareness of relevant UK regulatory frameworks matters.
Red flags: Blank looks at UK GDPR questions. No awareness of IR35 implications. Large upfront payment requirements (legitimate agencies typically ask for 25–33% upfront, with the balance tied to milestones). No UK-based point of contact for support.
Portfolio Red Flags vs Green Flags
| Portfolio Green Flags | Portfolio Red Flags |
|---|---|
| Live, working links to delivered products | Screenshots only — no live demos |
| Case studies with measurable business outcomes | Vague descriptions — "we built X for Y" |
| Work in your industry or similar complexity | Only startup MVPs or simple brochure sites |
| Projects that are clearly maintained post-launch | Projects that no longer exist or are clearly abandoned |
| Clients you can call independently | Anonymous case studies you cannot verify |
| Consistent visual and technical quality | Wide quality variation suggesting different actual teams |
The Discovery Process: Why It Matters More Than Anything
If there is one single differentiator between software agencies that consistently deliver and those that consistently disappoint, it is the quality of their discovery process. Discovery is not a sales activity — it is the technical and strategic work that makes accurate scoping, honest timelines, and successful delivery possible.
A quality discovery process produces:
- A detailed specification that all parties agree represents what will be built
- A data model and architecture design that will not need to be rebuilt in 12 months
- A timeline and budget that have been tested against the actual complexity of the work
- UX wireframes or prototypes that validate the user experience before expensive development begins
- A risk register that identifies the most likely project risks and mitigation plans
Discovery typically costs 10–15% of the total project budget. Any agency that offers to skip it or include it "for free" in the sales process is not doing it properly — and is leaving you exposed to the most common causes of project failure.
FAQ: Choosing a Software Development Company UK
How much does a UK software development agency cost?
UK agency day rates for development range from £350–£1,200/day depending on team seniority. Project costs typically start at £25,000 for a simple MVP and range to £500,000+ for complex platforms. The right budget depends on scope — use a paid discovery engagement to establish a realistic number before committing to a full build.
Should I choose a local UK agency or an offshore team?
Local UK agencies cost more but provide timezone alignment, easier in-person meetings, UK legal framework familiarity, and typically stronger accountability. Offshore teams (Eastern Europe, India) cost 40–70% less but require significantly more client-side project management. For complex, high-stakes projects, a UK agency with offshore technical capacity (many operate this way) is often the best balance.
How do I know if a UK software agency is credible?
Check: Companies House registration (how long have they been trading?), LinkedIn company page and employee profiles (does the company size match their claims?), independently verifiable client references, live portfolio links, and if possible a code quality review by an independent developer. Ask for a paid discovery engagement before committing to a full build — agencies that resist this are not confident in their own process.
What is a reasonable upfront payment for a software project in the UK?
Industry standard in the UK is 25–33% upfront, with the remainder split across milestones tied to deliverables. Be cautious of agencies asking for 50%+ upfront — it shifts risk substantially to you before they have delivered anything verifiable.
If you are evaluating software development partners and want to understand what good looks like for your specific project, speak to our team at BoldMe. We are transparent about our process, our team, and our pricing — and we encourage the kind of due diligence this article describes.