How to Vet a Software Development Partner: 20 Questions Before You Sign

Twenty questions for the founder, the engineers who will do the work, their references and yourself, plus how to verify each answer before you sign.

How to Vet a Software Development Partner — Blurbee Solutions

Most vendor vetting is aimed at the wrong people. The buyer spends hours with a sales lead and a slide deck, reads three case studies, and signs. Then the engineers they meet on kickoff day are strangers, and the first real evidence of quality arrives a month later.

Vetting works better when you question four different groups: the founder or delivery lead, the engineers who will do the work, the vendor's past clients, and your own team. Then you verify with real work.

This article is about who to ask and how to check. For contract, quality and security questions, see our earlier checklist: 20 questions to ask before signing an offshore development team. The two overlap very little.

Five questions for the founder or delivery lead

These are about accountability. You want to know who carries the outcome when something goes wrong.

  1. Who will be our named delivery lead, and what happens if they leave? You want a name, and a written handover process.
  2. What is the biggest project you have lost or had to rescue, and what changed afterwards? A vendor with no answer has either not been tested or will not tell you.
  3. How do you price when scope changes? Look for a clear change process, not "we're flexible".
  4. What would make you turn this project down? Good vendors decline work that does not fit them. The answer shows whether they understand their own limits.
  5. How much of the work is subcontracted, and to whom? Especially relevant in markets where local firms resell offshore delivery.

Five questions for the engineers

Ask to speak with the people who will write the code, before signing. A vendor who refuses is telling you something.

  1. Walk me through your last pull request. What changed, who reviewed it, and what feedback did they get? This shows review culture in minutes.
  2. How do you test something like our main feature? Listen for unit, integration and end-to-end testing appropriate to the risk, not a stock answer.
  3. What happens when you disagree with a requirement? You want engineers who raise concerns in writing, early, not ones who quietly build the wrong thing.
  4. How do you know a release is safe? Automated checks, staging, feature flags and rollback, described concretely.
  5. What did you learn on your last project that you would do differently? Engineers who reflect produce better work.

Five questions for references

Ask for at least three references, including one engagement that has ended. Current clients are often in the honeymoon period; former clients know how the relationship finished.

  1. What went wrong, and how was it handled? Something always goes wrong. You want to hear how.
  2. Did the team you met at the start stay on the project? Staff continuity predicts quality.
  3. How close were the estimates? Not whether they were exact, but whether surprises were raised early.
  4. How did the engagement end, and was the handover complete? Code, accounts, documentation and knowledge.
  5. Would you hire them again for the same kind of work? Listen for hesitation and for "the same kind of work". Many vendors are good at one thing and sold as good at everything.

Five questions for yourself

Many engagements fail on the client side. Ask these honestly before you blame a vendor for a project that was never set up to succeed.

  1. Who on our side owns decisions, and do they have time? A product owner with two hours a week will bottleneck any team.
  2. Do we have written acceptance criteria for the first release? If not, no vendor can hit them.
  3. Who will review the code? If nobody technical on your side can, arrange an independent reviewer.
  4. What is our real budget, including our own time? Management overhead is part of the cost.
  5. What is our exit plan? Accounts, repositories and documentation in our name from day one make every other risk smaller.

How to verify the answers

Answers are claims. Four ways to check them:

Put the code in your repository from day one. Then you can see commit history, review quality and test coverage yourself, continuously.

Talk to the actual engineers, not only the sales team. Twenty minutes with the people doing the work tells you more than a two-hour pitch.

Call a reference from an ended engagement. The most honest reference is one with nothing left to gain.

Run a paid, fixed-scope first project. Two to four weeks of real work, with clear acceptance criteria, shows code quality, communication, how problems are raised and whether estimates hold. It is the most predictive step in the whole process and costs a small fraction of the full engagement.

How to run the paid first project

A paid first project is only useful if it is set up to reveal something. Five rules:

Pick real work, not a toy. Choose a small but genuine slice of the product: one complete flow, from interface to database, including tests and deployment. A standalone prototype tells you little about how the team handles your codebase, conventions and review process.

Write acceptance criteria before starting. What must the feature do, what must it not do, what performance and accessibility levels are required, and how will you test it? Criteria written afterwards turn into arguments.

Use your tools. Your repository, your issue tracker, your CI pipeline, your communication channels. You are testing how the vendor works inside your environment, because that is where the real engagement will happen.

Watch the process, not just the result. How early were questions raised? Were blockers flagged or hidden? Did the daily handoffs say something useful? Did estimates move, and were you told when they did?

Review the code properly. If nobody on your team can do it, pay an independent reviewer for a day. It is cheap insurance against a polished demo sitting on a fragile codebase.

A simple scorecard

At the end of the first project, score each area from one to five, with evidence:

Area What to look at
Correctness Did it meet every acceptance criterion?
Code quality Readable, tested, consistent with your conventions?
Communication Were questions and risks raised early and in writing?
Estimation How close was delivery to the estimate, and were changes flagged?
Ownership Did the team take responsibility for problems, or explain them away?
Handover Could someone else pick this up tomorrow from the repository and notes?

If you are comparing two vendors, give both the same project and the same scorecard. The differences are usually obvious by the second week, and they are the differences that decide how the next year goes.

Red flags

  • The team cannot be named before signing.
  • No references from engagements that have ended.
  • Code kept in the vendor's repositories "until handover".
  • Vague answers about who owns accounts and IP.
  • Pressure to sign a long contract before any delivered work.
  • Estimates that never move however the scope changes.

The same rules everywhere

These questions apply whether the vendor is in Bengaluru, New York, London, Toronto or Dubai. Location changes the overlap hours and the contract law, not what good delivery looks like. For how markets compare on rates and delivery models, see tier-1 city tech partners compared.

Vet us the same way

We will answer all twenty, put you on a call with the engineers who would do the work, and give you references including an engagement that ended. Then we will price a fixed-scope first project so you can judge us on delivered work rather than on this article.

Vetting a partner, in numbers

4 groupsPeople to question: the founder or lead, the engineers, their references and your own teamBlurbee vetting framework
2-4 weeksA paid, fixed-scope first project reveals more than any number of proposalsBlurbee engagement model
3+Reference calls, at least one with a client whose engagement has endedBlurbee recommendation
Day 1When code should start landing in your repository, not the vendor'sBlurbee engagement model
How much each vetting method tells you about delivery

Blurbee's assessment, scored out of 10 for how well each method predicts delivery quality. Opinion based on our engagements, not a survey.

  • Paid first project 10
  • Call with the actual engineers 8
  • Reference from an ended engagement 8
  • Code sample review 6
  • Case studies and portfolio 3
  • Proposal document 2
Predictive value, out of 10

Why we publish our own vetting checklist

Because we would rather be chosen by buyers who checked. We name the delivery lead before signing, put the code in your repository from the first commit and assign IP in writing. None of that is hard to verify, and you should.

  • Fixed-scope first projectTwo to four weeks, priced as a number rather than an estimate, so you have evidence before a longer commitment.
  • One delivery lead, namedYou always know who to ask. No account manager relaying questions to a team you never meet.
  • Code and IP are yoursAssigned in writing, handed over with repositories, infrastructure definitions and documentation whether or not you continue with us.
  • Performance budgets in CICore Web Vitals and bundle size gate the build. Slow does not ship.
  • Accessibility to WCAG 2.2 AAReviewed with automated and manual passes, not claimed on a slide.
  • Written overlap disciplineStanding calls inside your working window, everything else asynchronous with a decision log.

Frequently asked questions

Frequently asked questions

How do you vet a software development partner?

What is the most important question to ask?

How is this different from your other 20 questions article?
How should we check references?
Is a paid trial project worth it?
Should we review a code sample?
What are the red flags when vetting a vendor?
What questions should we ask ourselves?
Do these questions apply to local vendors too?
How long should vetting take?

Start with a fixed-scope first project

Two to four weeks, priced as a number. Code, accounts and IP stay in your name.