# Software development partner evaluation checklist: 43 checks before you sign

URL: https://pixelactstudio.com/resources/software-partner-evaluation-checklist

> Software development partner evaluation checklist: 43 checks on diagnosis, proof, team, engineering, ownership, contracts, and AI use, each with its reason.

A software development partner evaluation checklist is a set of yes or no checks you apply to every studio or agency on your shortlist before you sign. A partner worth hiring diagnoses before it quotes, labels its proof, names who does the work, shows its engineering standards, keeps code in your accounts, and puts terms and AI use in writing.

This checklist is for a founder, CTO, or head of product at a seed or Series A startup with a funded plan, no dependable team to build it, and an outside partner to choose. The same checks apply to studios, agencies, and freelance teams, so every name on the shortlist is judged on the same terms.

## How do you vet a software agency with this checklist?

Vet a software agency by scoring it on evidence at three points: after the first call, after the proposal walkthrough, and after a reference call. The first call shows how a partner diagnoses, the proposal shows its scope and terms, and the reference shows how it handles problems.

- Mark a check yes only for something you saw: a document, a repository, a contract clause, or a person you met.
- Count “we usually do that” and “we can add that later” as no.
- Score each partner in its own column, and note the evidence behind every yes.

Our guide on [choosing a software development company](https://pixelactstudio.com/blog/choosing-a-software-development-partner) explains the reasoning behind each group of checks. A studio that sells builds wrote this checklist, so apply every check to us as well.

## Did they diagnose before they quoted?

- [ ] Did they ask about your users, current workflow, data sources, integrations, deadline, and who decides before they talked about price or stack? A quote produced without those answers prices a product the partner imagined, not yours. The gap returns later as change requests for things nobody asked about, such as a CSV import or a CRM sync.
- [ ] Did they ask what prompted the project now, and what a good outcome looks like in business terms? A partner that knows the outcome, such as “three pilot customers onboarded by March”, can cut scope to protect it. One that only knows the feature list builds all of it and misses the date.
- [ ] For an existing product, did they ask to read the code, or recommend a paid review, before quoting a rescue, migration, or large feature? Inherited code hides problems no call can surface, such as a schema with no tenant boundary or migrations that were never committed. A price given without reading the code rests on assumptions you pay for later.
- [ ] Did they give a price range on the first call, and an exact price only in a written proposal that lists its assumptions? A range early lets you check budget fit without anyone guessing at detail. Written assumptions, such as “Stripe Checkout, not a custom billing flow”, show exactly what would move the price.
- [ ] Did they question or push back on at least one part of your plan? A partner that agrees with everything is waiting for tickets, and you lose the senior judgment you are paying for. A useful challenge sounds like “launch with email sign-in and add single sign-on when the first enterprise customer asks for it”.
- [ ] Does the proposal list deliverables, exclusions, milestones with acceptance criteria, and what you must provide? Scope arguments usually start where each side assumed the other had something covered. An exclusion such as “no data migration from the old system” settles the question before it costs money.
- [ ] When the risk was unclear, did they offer a smaller paid first step, such as an audit or a pilot, before the full build? A short fixed-price step shows how the partner works on your problem for a fraction of the build budget. A partner that only sells the full build asks you to take all the risk at once.

## Is their proof labeled and checkable?

- [ ] Is every portfolio item labeled as paid client work, the partner's own product, open source, or a design concept? AI design tools make polished screens cheap, so an unlabeled mockup can pass for a shipped product. The label tells you what you are judging: engineering, design, or neither.
- [ ] Can you open at least one item close to your problem, as a live product or a public repository? Screenshots hide everything behind the interface. A live product lets you test sign-up and error states, and a public repository shows the commit history, pull requests, and CI runs.
- [ ] Did you speak to a reference whose project is past launch, and ask what went wrong and how the partner handled it? Problems are normal on any project, and how the partner handled them is something no portfolio can show. A reference past launch can also tell you whether handover worked and whether their own engineers could take over.
- [ ] Are the people behind the work you were shown the same people who would work on your project? A case study built by a team that has since left proves little about the team you would get. Ask who led it and whether that person is free for your timeline.
- [ ] For any result a case study claims, can the partner say what was measured, from which baseline, and by whom? A line such as “cut load times in half” can mean one page on one fast laptop. A partner with real results can explain the baseline, the method, and the date.

## Who does the work, and how will you hear from them?

- [ ] Have you met the named lead engineer for your project before signing? The person on the sales call is often not the person in the repository. The lead's judgment on the data model, code review, and trade-offs is what you are paying for, so judge it directly.
- [ ] Did they say whether any work goes to subcontractors or freelancers, and confirm the same IP and confidentiality terms bind them? Undisclosed subcontracting puts your code and data with people you never vetted. If their contract with the partner has no IP assignment, the chain of ownership to you can break.
- [ ] Can they say what happens if the lead leaves or falls ill halfway through the project? Teams of every size lose people. A good answer names a second engineer who already reviews the code, plus [architecture decision records](https://pixelactstudio.com/blog/architecture-decision-records) and runbooks that keep the reasoning in your repository.
- [ ] Do you know how many hours of your working day overlap with theirs, and how quickly they reply in writing? A blocking question asked at 5pm and answered the next afternoon costs a day each time it happens. Agree an overlap window and a written reply time, such as one business day, before kickoff.
- [ ] Have you agreed a demo rhythm where you click through working software in a preview environment at least every two weeks? Status reports and percentages hide problems a working build exposes in minutes. A preview link per pull request lets you check progress without waiting for a meeting.
- [ ] Did they show a sample written update that covers what shipped, what is next, what is blocked, and which decisions they need from you? Decisions made on calls and never written down get argued again weeks later. A written update also shows early when the timeline depends on feedback you owe.

## Can they show their engineering standards in practice?

- [ ] Did they walk you through a reviewed pull request, with its comments and CI checks, from open source or a project they may show? Anyone can say “we review all code”. A real pull request shows whether review catches design problems or only approves, and whether a failing check actually blocks the merge.
- [ ] Do their default automated tests cover sign-in, permissions, billing, and, in a multi-tenant product, tenant isolation? A coverage number can climb on easy code while the paths that lose money go untested. One test proving that account A cannot read account B's data guards against a breach-level bug.
- [ ] Can they explain how they undo a bad release, and when they last did it? Every team ships a broken release eventually. Feature flags or a one-step redeploy of the previous version turn it into a short incident, as our guide to [safe releases and rollbacks](https://pixelactstudio.com/blog/safe-releases-and-rollbacks) explains.
- [ ] Do error tracking, structured logs, and an uptime check go in before launch, not after the first incident? Without them, a broken sign-up flow surfaces as a customer email days later. Error tracking with a tool such as Sentry can go in within a day, while structured logs and OpenTelemetry traces are far harder to retrofit across code written without them.
- [ ] Can they say how they keep secrets out of the repository, scan dependencies, and check for common risks such as those in the OWASP Top 10? Keys committed to Git stay in its history after the file is deleted, and vulnerable packages ship without anyone noticing. [NIST's Secure Software Development Framework](https://csrc.nist.gov/pubs/sp/800/218/final) gives buyers a shared vocabulary for asking suppliers about these practices.
- [ ] Do they write down architecture decisions, and did they show you one? Six months later, nobody remembers why the team chose Postgres over Firestore or one service over three. A short record per major choice lets your next engineer change course without repeating the debate.

## Will you own the code, the accounts, and the knowledge?

- [ ] Will the repository live in your company's GitHub or GitLab organization from day one, with the partner invited as members? A repository in the vendor's account turns handover into a negotiation and puts the history at risk if the relationship ends badly. Owning it from the first commit costs nothing.
- [ ] Will hosting, domains, DNS, app store accounts, and paid APIs sit in your company's name and on your billing? A domain or Apple developer account registered to a contractor can take weeks to recover. Paying providers directly also shows you the real running costs from the first month.
- [ ] Will at least two people on your side hold owner access to every account, with multi-factor authentication enforced? A single owner is a single point of failure, whether that is your cofounder or the partner. With two owners and MFA, one lost phone or one departure cannot lock the company out.
- [ ] Could you remove the partner's access and rotate every credential in one afternoon, using a written access list? Offboarding without a list leaves old deploy keys and API tokens active for months. A list of who holds what, plus secrets in a manager you control, turns the exit into a checklist rather than a search.
- [ ] Does the handover include a README that takes a new engineer from a fresh clone to a running app, an `.env.example` file, runbooks, and decision records? Code alone is not a handover. An engineer who has never met the partner should be able to run, change, and deploy the product from what sits in the repository.
- [ ] Will your own engineer, or one you hire, run a deploy and a rollback with the partner watching before the final milestone? A handover document nobody has tested is a guess. One real deploy while the partner can still answer questions finds the missing steps while they are cheap to fix.

## Do the contract and payment terms protect you?

- [ ] Does the agreement say which rights in the code pass to you, when they pass, and on what condition, such as final payment? Paying an invoice does not by itself transfer rights in code. In the US, the UK, and Canada a contractor generally keeps the copyright unless a written assignment says otherwise, and German law grants exclusive usage rights instead of an assignment, so have a lawyer read the clause.
- [ ] Does the contract give you a permanent, transferable license to any reusable code the partner brings, such as its own libraries or starter kits? Partners often build on code they reuse across clients, and that code stays theirs. Without a license that survives a sale of your company, you may own the product but not the parts it cannot run without.
- [ ] Are payments after the deposit tied to milestones that end in working software you accept against written criteria? Payments on calendar dates keep flowing whether or not anything works. A split such as 40% at start, 30% at a working midpoint, and 30% at launch keeps money and progress in step.
- [ ] Is there a written change request process, where each change is quoted and approved before work starts? Unpriced changes either get folded quietly into the estimate or arrive as a surprise invoice. A quote per change keeps scope and budget visible to both sides.
- [ ] Does the contract say what you receive if either side ends it early, including code and work paid for to date? A termination clause written only for the vendor can leave you paying for work you cannot access. Check the notice period and exactly what transfers on exit.
- [ ] Are third-party costs, such as hosting, email, and AI APIs, listed with monthly estimates and passed through at cost? Usage-priced services grow with every active user, and a markup hidden in a hosting bill repeats every month. Listing them in the proposal shows the real cost of running the product.
- [ ] If the partner will touch personal data, is there a data processing agreement? Under UK GDPR and the EU GDPR, a partner that handles personal data on your behalf acts as a processor, and [Article 28](https://gdpr-info.eu/art-28-gdpr/) requires a contract with specific terms. Enterprise customers' security questionnaires often ask for it as well.

## Is their AI use written down and reviewed?

- [ ] Do they have a written AI use policy that names the tools they use and what those tools draft? AI coding tools are a normal part of how good teams ship quickly. Without a written policy, you cannot tell whether the speed comes with review or with debt you inherit later.
- [ ] Does every AI-drafted change go through the same human review and CI as other code, with an AI approval never counting as the review? AI-drafted code can read cleanly and still skip an authorization check on one endpoint. Our [AI code review workflow](https://pixelactstudio.com/blog/ai-code-review-workflow) shows how a named engineer who can explain every line stops that from merging.
- [ ] Do they keep customer data, production secrets, and your source code out of any AI tool you have not approved? Whether prompts are retained or used for training depends on the AI vendor's plan and settings. Ask which vendors they use under which terms, and require written approval before real customer data goes into a prompt.
- [ ] Does the contract assign all deliverables to you however they were produced, including AI-assisted code? The [US Copyright Office concluded in January 2025](https://www.copyright.gov/newsnet/2025/1060.html) that AI output is protected only where a human author determined enough of its expressive elements, and that prompts alone are not enough. Some AI-drafted lines may carry no copyright at all, so the contract has to say that you receive every deliverable and the partner keeps no claim to any of it.
- [ ] Did they explain how they would review a prototype you built with AI tools before building on it? Building a first version with AI tools is a sensible speed trade that can prove demand quickly. A good partner checks it for exposed secrets, permissions, and missing tests before adding features, the gaps our [AI-built app risk checklist](https://pixelactstudio.com/resources/ai-built-app-risk-checklist) covers.
- [ ] When AI is part of the product, does the proposal state data boundaries, how the feature is expected to fail, and how accuracy and cost will be measured? A model that is sometimes wrong can still be useful if everyone agreed in advance what happens then, such as a human review queue. A pilot that measures accuracy and cost on your own data turns those limits into numbers.

## How do you score a software development partner evaluation checklist?

Score each partner group by group, not by total. A partner with 38 yes answers can still be the wrong choice if its five gaps sit in ownership and contracts, because those are the hardest to fix once work has started.

### Which failures are red flags?

A red flag is a failed check that gets expensive to fix once the contract is signed. Watch for these:

- **A fixed price for a full build** before anyone asked about your users, data, or code.
- **The repository, hosting, or domain in the vendor's accounts**, or reluctance to move them.
- **No named lead you have met**, or subcontractors you hear about late.
- **An IP clause that is missing or vague**, or one that keeps rights with the vendor.
- **No written exclusions or acceptance criteria** in the proposal.
- **Unlabeled proof**, or concepts shown as shipped client products.
- **No answer on who reviews AI-drafted code** or where your data goes.

One red flag is a reason to ask more questions and get the answers in writing. Two or more usually mean you should keep looking.

### When does an outside review make sense?

Get an outside review when the partners you are comparing would build on code you already have, or when your plan is still too loose for two partners to quote the same thing. A [software audit](https://pixelactstudio.com/services/software-audits) from $2,500 reviews the code or the plan and ends in a written report every partner can quote from, and you keep the report whichever partner you choose. When you are ready to build, our [product development](https://pixelactstudio.com/services/product-development) service is priced by milestone and starts with a 45-minute discovery call.

## Frequently asked questions

### What are the most important software vendor evaluation criteria for a startup?

The criteria that matter most are the ones that are expensive to fix later: who owns the repository and accounts, what rights the IP clause gives you, who leads the work, and whether every change is reviewed and tested. Price and portfolio polish matter too, but a cheaper quote with your code in the vendor's account usually costs more by the first handover.

### Can we use this checklist to vet freelancers as well as agencies?

Yes. Most checks apply unchanged, especially ownership, IP assignment, and code review. Adjust the team group: a solo freelancer has no second engineer, so ask who reviews their code and what happens if they become unavailable. Decision records, runbooks, and accounts in your name matter even more with one person, because nobody else holds the context.

### Is it reasonable to ask a partner to show real code before we sign?

Yes, within limits. Client code is usually confidential, so expect a walkthrough on a screen share, an open source repository, or the partner's own product rather than files sent to you. What you want to see is a pull request with real review comments and the CI checks that ran. A partner with no code it can show at all should be able to explain why.

### How long does development partner due diligence take?

For each partner, plan on a discovery call, a proposal walkthrough, a reference call, and an hour to score the results. That usually fits into one to two weeks, and two or three partners are enough to compare. If the decision needs more certainty than calls can give, a small paid audit or pilot tells you more than another round of meetings.

### How does Pixelact score on its own checklist?

Score us the same way. We have no client case studies yet, so our proof is labeled Open Source, such as [Commitscape](https://pixelactstudio.com/work/commitscape), whose code, pull requests, CI runs, and decision records are public. Every project has a named lead, the repository and accounts are yours from day one, code and IP transfer on final payment, and our [engineering standards](https://pixelactstudio.com/about/engineering-standards) are written down. A [pilot sprint](https://pixelactstudio.com/services/pilot-sprints) from $4,500 is a fixed-price way to see how we work before a build.