Skip to content

Guide

How to choose a software development company: questions and red flags

Choose a software development company on evidence you can inspect: how it diagnoses, what its scope excludes, who leads, who owns the code, how it tests and uses AI, and how payments follow working software.

  • Published
  • Updated
  • 10 min read
  • By Dev Talan

Key takeaways

The short version. Each point is explained in full below.

  1. 01

    Compare two or three companies. Ask each the same questions, and line up exclusions, milestones, and acceptance criteria side by side before you compare totals.

  2. 02

    A careful partner asks about your problem, users, data, and deadline before quoting, gives a range on the first call and an exact price only in writing, and reads existing code before it prices a rescue or rework.

  3. 03

    Create the repository, hosting, and paid services under your company and invite the partner as members. Have a lawyer check that the agreement says what IP is assigned to you, when, and whether payment is a condition.

  4. 04

    Ask to see a real pull request with its review comments and CI run, and ask how AI tools are used, who reviews their output, and whether customer data ever goes into a prompt.

  5. 05

    One red flag is a reason to ask more questions, and two or more usually mean you should keep looking. The clearest are a fixed price for a full build before anyone has seen the details, accounts held by the vendor, and no written exclusions.

To choose a software development company, judge evidence of how it works, not how it pitches. Check eight things: whether it diagnoses before quoting, writes scope and exclusions, names who leads, keeps code in your accounts, reviews and tests every change, has a written AI policy, ties payment to working software, and labels its proof honestly.

This guide is for a seed or Series A founder with a funded plan and no dependable team to build it, about to commit a first real budget to an outside partner. Pixelact, a studio that designs and builds software for funded startups, wrote it, so every check below asks for something you can verify. Apply each one to us as well.

How do you choose a software development company?

#

Choose on the practices that decide how the product holds up six months after launch, and treat the portfolio as one input. AI tools now make polished screens quick to produce, so a good-looking demo says little about the review, testing, and ownership behind it.

  1. 01Diagnosis. They ask about your problem, users, and constraints before they talk about price or stack.
  2. 02Written scope. The proposal lists deliverables, exclusions, and milestones with acceptance criteria.
  3. 03A named lead. One engineer you can name owns delivery and reviews the code.
  4. 04Ownership. The repository and accounts are yours from the first day, and the agreement says when IP transfers.
  5. 05Review and testing. Every change goes through a reviewed pull request and CI before it merges.
  6. 06AI policy. They can say what AI tools draft, who checks the output, and which data stays out of prompts.
  7. 07Payment. Payments follow milestones that end in working software you accept.
  8. 08Proof. Each portfolio item says whether it is client work, a studio demonstration, open source, or a concept.

Which questions should you ask a software development agency?

#

Ask questions that make the agency describe what it does on a project, then ask to see the evidence. A good answer is specific and names something you could inspect. A weak answer describes values instead of practice.

QuestionA good answer sounds likeA weak answer sounds like
What do you need to know before you can quote?Your users, data, integrations, deadline, and who decides. For existing code: “We need to read it first.”A fixed price after one short call, with no questions about your data or code
What is not included in this proposal?A written exclusions list, with a reason for each line“We'll handle whatever comes up.”
Who leads our project, and will they work in the repository?A named engineer who joins your calls, reviews pull requests, and owns delivery“A project manager will coordinate with the team.”
Whose accounts will the repository and hosting be in?Yours, from the first day, with the partner invited as members“We host it for you and hand it over at the end.”
Can you show us a reviewed pull request and its CI run?They open one and walk through the review comments and the checks that must pass before mergeA dashboard screenshot, or “our process is agile”
How do you use AI tools, and who checks the output?AI drafts, an engineer reviews every change, and customer data stays out of prompts without your written approvalNo written policy, or no clear answer on who reviews AI-drafted code
How are payments tied to progress?A deposit, then payments at milestones that end in working software you acceptPayments on calendar dates, unrelated to what has been delivered
What does handover include?Repository history, tests, CI, a README, runbooks, decision records, and a walkthrough with whoever takes over“We'll send you the code.”
What kind of proof is this, and can we speak to a client?Every portfolio item labeled, and a reference whose project is past launchLogos with no one you can contact, or concepts shown as shipped products
Questions to ask a software development agency, and what good and weak answers sound like

How can you tell whether a partner diagnoses before quoting?

#

A partner who diagnoses first spends most of the first call asking questions: what prompted this now, how the work happens today, what a good outcome looks like, and who makes the decision. It gives a price range on that call and an exact price only in a written proposal.

For an existing product, a good partner reads the code before it quotes a rescue, a migration, or a large feature, because inherited code hides problems no call can surface. That reading is usually paid work. At Pixelact it is a software audit, from $2,500: about 3 to 5 days of review, ending in a written report that ranks risks and fixes and a build path with rough costs.

A confident plan can still be a guess

A fixed price or detailed architecture produced before anyone has seen your data, integrations, or code rests on assumptions. Ask for those assumptions in writing, or they return later as change requests.

What should the written scope and exclusions say?

#

The written scope should let someone who missed every call say what will be built, what will not, and how each part will be accepted. Before you sign, check that the proposal covers each of these.

  • Your goal, restated in your own words, so you can correct anything misread
  • Deliverables as a list you can check off
  • An explicit list of exclusions, such as a native mobile app, a data migration, or an admin back office
  • Milestones, each ending in working software with written acceptance criteria
  • What you provide: access, data, a decision-maker, and feedback times
  • How change requests are priced and approved before work starts
  • Third-party services, such as hosting and paid APIs, with an estimated monthly cost for each
  • IP assignment and code handover terms
  • Data boundaries and expected failures, when AI is part of the system

Exclusions do the most work, because a scope dispute usually starts with something each side assumed the other had covered. Our guide to scoping an MVP shows how to write exclusions and acceptance criteria for a first release.

Who will lead and build your product?

#

A named engineer should lead your project, and you should meet that person before you sign. Ask for the name, and ask whether they are on the sales call. The lead should run your calls, own the architecture, review the code, and be the one you ask about anything.

  • Ask who reviews pull requests. The reviewer is the person whose judgment you are paying for.
  • Ask about subcontractors. If any work goes to another company or to freelancers, ask who they are and whether the same IP terms bind them.
  • Ask what happens if the lead leaves. A good answer points to decision records, runbooks, and a second engineer who already knows the code.

Written decisions protect you here. When a team records its choices in architecture decision records, the reasoning stays in your repository when people change.

Who owns the code, and what does handover include?

#

You should own the code, and the accounts it runs on should be yours from the start. Create the repository, hosting, and paid services under your company, invite the partner as members, and pay providers directly. Then no part of the product depends on an account only the vendor controls.

Ownership of the code itself is a contract question, so don't assume that paying an invoice settles it. The agreement should say what is assigned to you, when the assignment happens, whether payment is a condition, and how any libraries the partner reuses are licensed to you. Have a lawyer read that clause. At Pixelact, the accounts are yours from day one, and code and IP transfer once the final invoice is paid.

Handover is complete when an engineer who has never met the partner can run, change, and deploy the product. Ask for these:

  • The full commit history, tests, and CI in your repository
  • A README that takes a new engineer from a fresh clone to a running app
  • An .env.example file that names every environment variable without real values
  • Runbooks for deploys, rollbacks, and restoring a backup
  • Decision records for the main technical choices
  • A list of who holds access to what, so you can remove the partner's access when you choose

How do you check a partner's testing and code review practices?

#

Ask to see the practice itself. A partner that reviews and tests every change can open a pull request and show the review comments, the CI checks that ran, and the branch rule that stops a change from merging while a check fails.

Look for tests where a failure would cost money or trust: sign-up and sign-in, permissions, billing, the core workflow, and, in a product with many customer accounts, a test proving one account cannot read another's data. A coverage percentage proves little on its own, because it can rise while those paths stay untested.

Once work starts in your repository, during a pilot sprint for example, you can check the basics yourself with the GitHub CLI.

Run with admin access to see who owns the repository, the protection and ruleset rules on main, and the reviews on recent merges. A Branch not protected reply plus an empty rules list means nothing blocks an unreviewed merge. A merge with no APPROVED review went in without an approval.bash
gh repo view your-org/your-product --json owner,visibility
gh api repos/your-org/your-product/branches/main/protection
gh api repos/your-org/your-product/rules/branches/main
gh pr list --repo your-org/your-product --state merged --limit 10 --json number,title,latestReviews --jq '.[] | {number, title, reviews: [.latestReviews[].state]}'

What should a partner's AI use policy say?

#

A good AI use policy says what AI tools draft, who reviews the result, and what data never goes into a prompt. Using AI tools is normal, and it is part of why good teams deliver faster. The question to ask is whether the speed comes with review.

Review matters because AI output can look finished before it is. Veracode's 2025 GenAI Code Security Report tested more than 100 large language models on 80 coding tasks and found that the generated code introduced security vulnerabilities in 45 percent of cases. A written policy should cover these points:

  • Every AI-drafted change goes through the same review and CI as any other code.
  • An AI reviewer's approval never counts as the review.
  • The author can explain every line, including lines a tool drafted.
  • Customer data stays out of prompts unless you approve it in writing.
  • When AI is part of the product, the proposal states its data boundaries and how it is expected to fail.

If your current prototype was built quickly with AI tools, that was a sensible speed trade. Ask each partner how it would review that code before building on it. Our AI code review workflow shows the steps we follow.

What payment structure is fair for a software project?

#

A fair payment structure ties money to working software. A deposit before work starts is normal, and so is paying upfront for a small fixed-scope package such as an audit. For a build, later payments should fall at milestones that end in software you accept against written criteria.

As one example, Pixelact's pilot and build quotes offer two or three of these plans: 100% upfront with 5% off, 50% / 50%, 50% / 25% / 25%, or 40% / 30% / 30% at start, working midpoint, and launch. Change requests are quoted before any work on them starts, and by default hosting and paid APIs sit in your accounts, paid by you directly.

What are the red flags when choosing a software agency?

#

Software agency red flags are signs that scope, ownership, or quality will be hard to hold the company to once work starts. One red flag is a reason to ask more questions. Two or more usually mean you should keep looking.

  • A fixed price for a full build before anyone has asked about your users, data, or integrations
  • The repository, hosting, or domain held in the vendor's accounts
  • A proposal with no exclusions and no acceptance criteria
  • No named engineer, or a senior person on sales calls who never appears in the repository
  • No written practice for code review, testing, or releases
  • Portfolio items with no label, or concepts presented as shipped client products
  • Reluctance to put scope, price, or terms in writing

How should you read references and proof?

#

Read each piece of proof for what it shows. A useful portfolio labels every item, so you can tell paid work from the studio's own product, public code, or a design.

Client Work
Paid work the client allowed the studio to show. Ask to speak to that client.
Studio Demonstration
A working product the studio built for itself, with no claims about users or revenue.
Open Source
Code anyone can read. Open the repository and look at the pull requests, CI runs, and decision records.
Concept
A design with no product behind it. It shows visual judgment and says nothing about engineering.

When you speak to a reference, ask what went wrong, how the partner handled it, and what happened at handover. Every project has problems, so the handling tells you more than the praise.

We apply the same labels to ourselves. Pixelact has no client case studies yet, so our public proof is labeled Open Source, such as Commitscape, a Damn Labs tool that reads a repository's git history to show what each developer built. Its code, pull requests, CI runs, and decision records are public on GitHub.

When does outsourcing software development make sense for a startup?

#

Outsourcing software development makes sense for a startup when the work is funded and time-bound and no dependable team is free to build it. Common cases are a first version before the first engineering hire, or one roadmap item an internal team can't reach this quarter.

Plan the exit from the start. If you intend to hire, the partner should build in your repository, write down its decisions, and hand over cleanly to your new engineer. If trust is still low, start with a small paid step, such as an audit or a pilot, before a larger commitment.

What should you do next?

#

Pick two or three companies, ask each the questions in the table above, and score the answers with the software partner evaluation checklist. Ask each one for a reviewed pull request and a sample proposal with its exclusions.

To see how we answer the same questions, read the engineering standards we hold every project to. If you have a funded plan to build, our product development page explains how a build is scoped and priced by milestone.

FAQ

Common questions

Short answers to what readers ask next about this topic.

Enough to hold a call and get a same-day answer on most working days. Ask how many of your working hours overlap with theirs, how quickly they reply, and how decisions reach you in writing. Our working day overlaps with UK and European business hours, and we schedule calls with US and Canadian teams in their morning. Overlap matters less when the named lead runs your calls and decisions land in your repository as decision records.

Two or three is usually enough. Each one needs a discovery call and a proposal walkthrough, so a longer list tends to turn the comparison into a price contest. Ask every company the same questions, write down the answers, and compare exclusions and milestones side by side before you look at the totals.

Sometimes, if it is lower because it builds less and you agree with what it leaves out. Line up the exclusions, milestones, and acceptance criteria from each proposal before you compare prices. A quote that is cheaper for the same written scope often rests on assumptions that return later as change requests, so ask the company to list them.

It should prove one thing about the product and show you how the partner works. Agree pass criteria before it starts, have the work done in your own repository, and watch the pull requests, reviews, CI runs, and decision records as they appear. The GitHub CLI commands in this guide show whether the main branch blocks unreviewed merges. Note how the partner handles a question it can't answer yet, because that is how it will handle the larger build.

Yes, and it works best when the rules are agreed at kickoff. Share one repository and one tracker, let your engineers review and approve pull requests in the areas they own, and write the branching, review, and release rules into the repository so both teams follow the same ones. Decisions go into the same decision records, whoever makes them.

If the product already has users and code, yes. Without one, every partner is quoting against guesses about the codebase, so the quotes are hard to compare. A written review that ranks risks and fixes gives each company the same starting point, and you keep the report whichever partner you choose.

Monthly newsletter

Get the next article by email

One short email a month on scoping, security, AI features, and releases, with links to new articles and checklists. Every issue is also published on the site, and every email has an unsubscribe link.

By subscribing, you agree to get the Pixelact newsletter by email. Every email has an unsubscribe link. Read the privacy notice.

Start a project

Tell us what you're building.

Share a few details in a short form, or book a discovery call if you're not sure where to start.

On the discovery call

  1. 01What prompted this now, and where things stand
  2. 02What a good outcome looks like
  3. 03Whether we're a fit, and what a next step could be

45 minutes. No slides, and no long questionnaire.