Skip to content
Blog

What Questions Should You Ask Before Engaging a Software Development Studio?

By David Solomon, CEO at Credo Solutions

The short answer: Most hiring checklists test whether a studio can build your software. Projects that go wrong rarely fail there. They fail on control: who holds the code, the accounts and the knowledge, and how you get out. Ask about control on the first call, in the proposal and in the contract, and don’t sign until the contract puts the code and every account in your name.

It usually goes like this. A 25-person home services business hires a software development company to replace the spreadsheets and phone calls behind their bookings. The first call goes well. The proposal is confident. Eight months later, the booking system half works, the developer who built it has moved on, and the studio wants a new contract to finish the job.

So the owner asks for the code. It sits in the studio’s account. So does the hosting. Nobody on the owner’s team has ever logged in to either, and the contract never said who owns what.

The owner asked what most checklists say to ask: can we see your portfolio, what technology do you use? A capable studio answers those well, and this one did. Nobody asked who would hold the keys.

That’s the gap. Competence questions tell you whether a studio can build your software. Control questions tell you whether you’ll still have it when something goes wrong. There are four things to control: the code, the accounts, the knowledge of how it all works, and your way out. Every question below tests one of them.

What should you ask on the first call?

The first call is where you learn who you’d depend on, and whether the studio wants you depending on it at all.

Could something we can buy do this instead?

Software you buy, you can cancel. Software built for you comes with code, accounts and know-how you’ll have to keep hold of for as long as you use it. The easiest software to control is software you never had built. A good studio checks for an off-the-shelf tool, or a built-in connection between tools you already pay for, before it pitches a project.

If every problem on the call becomes a build, the studio needs the project more than you do.

Who will actually build it, and can we meet them?

Knowledge lives in people. Ask for the names and roles of the people who will write your software, and ask to meet them before you sign, not after.

“Our team” is a sales answer. If nobody can name who writes the code, you’ll meet them for the first time when something breaks.

When will we see something working?

Every early version you use yourself is knowledge that ends up on your side, not theirs. A good answer is a date measured in weeks, then a steady rhythm of new versions you click through yourself. Each one teaches your team how the thing works before anyone is gone.

The booking-system owner saw the software for the first time at month eight. By then, every wrong turn was already paid for.

What should you look for in the proposal?

Before you look at the total, read what the proposal assumes and what you’d keep if you stopped partway.

Can anything change without our sign-off?

The control question comes before the price: can anything change without your written approval, and can you see where every hour went? Then read the assumptions written into the quote, lines like “one connection to your accounting software” or “you supply all the text and photos.” Each one is a change someone will have to approve.

A fixed price for a defined list of features protects the budget. Time and materials, where you pay for the hours worked, bends with change.

You will change your mind once you see the software working. A quote that arrives before anyone understands your problem is a guess with a number on it.

Can we talk to someone you’ve built for?

The studio may not name its clients publicly, but it should be able to introduce you to one with a problem like yours.

Then ask them the control question. Not “were you happy?” but: if you’d wanted to walk away halfway through, could you have?

What has to be in the contract?

Paying for software doesn’t make it yours. In most cases, when an outside firm writes code, the firm owns it until a written contract assigns it to you. You can pay every invoice and still not own what you paid for.

This isn’t legal advice. Have a lawyer review the contract before you sign.

When does the code become ours?

The contract should assign the code to you and say exactly when. It should also list the main open-source libraries and outside services your software uses, and give you a license that outlasts the contract for any of the studio’s own tools inside it.

If ownership isn’t in the contract, assume it isn’t yours.

Whose name are the accounts in, and who can see our data?

The code repository, the hosting, the domain and any app store accounts should be in your company’s name from day one, with the studio added as a user. Ask, too, who on their side can see your customers’ real data.

“We keep everything in our accounts for convenience” is how the booking-system owner ended up asking for code they’d paid for and couldn’t reach.

What happens if this ends early?

Projects end early for ordinary reasons: a budget changes, priorities shift, a partnership doesn’t work. The contract should say what you take with you for everything you’ve paid for: the code, the documentation and access to every account.

If the answer is “that won’t happen,” you’ve learned what you’d leave with: nothing in writing.

What happens after launch?

Get the support terms in writing before you sign. Software needs fixes and security updates for as long as you use it, and once the building stops, the studio’s team are the only people who know how it works.

Could someone else take this over?

This is the last test of control: if the studio vanished tomorrow, could someone else fix a bug next week using only what you hold?

The answer depends on a handover your own team has tried before the final payment, not a folder of files you open for the first time when you need it.

How we’d answer

On the first call. If a tool you can buy would do the job, we’ll say so. If it won’t, you meet your project lead and the engineers before you sign, you click through a first working version within two weeks, and only your project lead and engineers see real data.

In the proposal. We recommend a pricing model after the first call, every quote lists its assumptions, nothing changes until you approve it in writing, and time and materials invoices come with itemized timesheets. We don’t name clients publicly, so we introduce you to the one whose project is closest to yours.

In the contract. The code becomes yours as you pay for it, and your repository, hosting, domain and app store accounts are in your name from day one. If the work ends early, you keep the code and documentation for everything you’ve paid for, and every account.

After launch. Support terms are in writing, and every project ends with a documented handover that your team tests before the final payment.

Which questions should you take with you?

  1. Could something we can buy do this instead?
  2. Who will actually build it, and can we meet them?
  3. When will we see something working?
  4. Can anything change without our sign-off?
  5. Can we talk to someone you’ve built for?
  6. When does the code become ours?
  7. Whose name are the accounts in, and who can see our data?
  8. What happens if this ends early?
  9. Could someone else take this over?

What would have saved the booking system?

Two questions, asked before signing: whose name are the accounts in, and when does the code become ours? Ask all nine, and hire the studio that answers them plainly. Hold us to the same test.