Skip to content
Buyer's guide

How to choose a top SaaS development company. Criteria, not a ranking.

Search for a top SaaS development company and you get lists. Most were written by someone with a stake in the outcome — and if we published one, we would be on it. So this page publishes the criteria instead: what actually separates a build partner who ships from one who demos, the nine questions that surface the difference before you sign, how to read a proposal, what goes wrong and whose fault each failure really is, and when you should not hire an agency at all. Run it on us too. That is the point of writing it down.

Scroll
Why there is no list here

We are an engineering firm. On a page about choosing an engineering firm, that makes us a subject, not a judge.

A vendor’s own ranking of vendors is an advertisement with a table in it. You already know how it ends. What a ranking cannot give you — and what nobody seems to publish — is the checkable version: the criteria, the questions, the failing answers, and the cases where the right decision is to hire nobody.

So that is what this is. Everything below is meant to be used against a shortlist, including against us — there is a section at the bottom pointing at the four places on this site where these criteria can actually be run on Beyond Technologies, and one criterion we publicly fail.

Seven criteria

Checkable, or it doesn’t count. Each one has a way to verify it.

These hold for a SaaS platform and for a bespoke MVP development company alike, because none of them are about technology. They are about whether the shape of the engagement can produce a working system, which is a different question from whether the team is clever.

01

The people who scope it are the people who build it

Ask for names, then ask to interview them the way you would interview a hire — and ask who is on the project in month four. A scoping team that hands off to a delivery team has to re-learn your business twice and will bill you for both.

02

The engagement has a defined end

A named deliverable with a date beats an open discovery meter running against your budget with no visible finish line. If the first phase is discovery and the second phase is to be determined, you are buying a subscription to a decision that has not been made.

03

They can say what working means, as one number

Ask which single metric the engagement has to move and how you will both see it weekly. A partner who cannot name one has not understood the workflow well enough to build for it, and neither of you will be able to settle the question later.

04

They will tell you what to cut

Give them your scope and ask what they would remove. A firm that agrees with all of it is selling hours; every feature cut is revenue they chose to give up in exchange for the thing shipping. Ten minutes of this tells you more than a portfolio.

05

The code lives in your repositories from the first commit

Not transferred at the end once everything is settled — there from the beginning, in your version control, under your CI, with IP assigning to you on delivery in writing. Then there is nothing to hand over and nothing to hold.

06

They can show something that outlived its engagement

Anyone can show a launch. Ask for a system shipped years ago, who maintains it now, and what broke first. Long engagements are the honest evidence here: on this site the longest are a 150-branch student information system at 22 months and a province-wide education platform at 36+ months.

07

They price the unglamorous eighty percent

Migration, auth, permissions, tests, observability, the admin nobody demos. If a proposal is priced almost entirely around the interesting part, the boring part has not been scoped — and the boring part is where the schedule actually goes.

Nine questions

Ask these before you sign. The failing answers are the useful half.

A question list on its own is a listicle. What makes these worth carrying into a call is knowing which answers should end it — so each question below is paired with the reply that means keep looking.

  1. 01

    Who exactly will write this, and can I speak to them this week?

    An answer that should worry you

    A delivery pod with no names in it. Or a yes, followed by different faces at kickoff — the seniors who close the deal are not always the ones who stay on it.

  2. 02

    What is in scope, and what is the first thing you would cut?

    An answer that should worry you

    Nothing. A partner with no cut list has not read your scope closely enough to have an opinion about it, or has decided agreement is worth more than accuracy.

  3. 03

    What does this engagement have to move, and how will we both see it?

    An answer that should worry you

    We will define success together in discovery. You are being asked to pay for the definition, and to wait until after the money is committed to hear it.

  4. 04

    Where does the code live, and who owns it on delivery?

    An answer that should worry you

    Their repository, transferred at the end once everything is settled. Ownership that arrives late sometimes does not arrive.

  5. 05

    What happens when the estimate turns out to be wrong?

    An answer that should worry you

    It won't be. Every estimate is wrong; the only questions are who absorbs the difference and how early you are told.

  6. 06

    Who is on this in month four?

    An answer that should worry you

    A rotation policy, or no answer at all. Continuity is not a nice-to-have on a system nobody has documented yet.

  7. 07

    What did you last talk a client out of building?

    An answer that should worry you

    No example. Either nobody has trusted them enough to hear it, or they have never been willing to say it out loud.

  8. 08

    What is not included that I will end up paying for later?

    An answer that should worry you

    Nothing at all. Hosting, data migration, third-party fees, and the first year of keeping it alive are always somebody's cost — silence just decides whose.

  9. 09

    Can I see something you shipped that is still running two years later?

    An answer that should worry you

    Only recent demos and screenshots. Anyone can show a launch; the interesting question is what survived one.

Or put us through it

Bring the shortlist and the scope. We’ll tell you what we’d cut.

Book a call
Reading a proposal

Eight things a real one contains. Eight it substitutes instead.

Proposals are hard to compare because they are written to be hard to compare. This is the diff. Read both columns side by side against whatever is in your inbox — the gaps are the negotiation.

A real proposal contains
  • 01The actual people, by name, with the role each one holds for the duration.
  • 02What is excluded, stated as plainly as what is included.
  • 03A sequence with dates against it, not phases floating free of a calendar.
  • 04A definition of done for every deliverable, written before anyone argues about one.
  • 05Who owns the IP, and the date it transfers.
  • 06What changes the price, and roughly by how much.
  • 07What happens if it slips — whose cost, whose decision, and when you are told.
  • 08The handover: documentation, tests, a runbook, and a live walkthrough.
A thin one substitutes
  • A technology list. A stack is not a plan; it is a list of nouns.
  • A headcount of unnamed resources, which is a promise about volume, not people.
  • The word agile, doing the work a sequence with dates should be doing.
  • A phase table with no dates in it.
  • One lump sum, undivided, so nothing inside it can be questioned or removed.
  • Post-launch support for three months, with support left undefined.
  • Testimonials where the deliverables should be.
  • A start date, and nothing about an end.

One caveat on prices, since it applies to us as well: we publish no rate card, and neither should you trust one. A single figure across every project shape means the simple work is overpriced or the hard work is underpriced. Our reasoning is written up here. What you should insist on is a real number before you commit — just not one printed before anyone has seen the work.

Post-mortems

Eight ways a build goes wrong. Half of them are not the vendor’s.

Read the attribution before the explanation. A partner who cannot name the failures a buyer causes has either never had a hard client conversation or does not intend to have one with you.

01

The scope changed every week

Fault: Yours

A vendor can absorb three changes and still hit a date. Thirty is a different project, arriving one request at a time. The fix is unglamorous: one person on your side who can say no, and a written change log that both sides can point at.

02

It was built on assumptions nobody wrote down

Fault: Shared

You knew the invoicing rule and nobody asked. They assumed the obvious thing and nobody checked. Both sides could have written it down in an afternoon, which is why this one is shared and why it is the most common.

03

Nobody could say whether it was working

Fault: Theirs

If the engagement never had a number attached, no amount of delivery closes the question. Agreeing one metric before the build starts is the vendor's job, because they are the ones who know which numbers are actually measurable.

04

The one person who understood it left

Fault: Theirs

Knowledge concentrated in one head is a staffing decision, not bad luck. Two people who can each explain the system, and documentation that survives them both, is a deliverable — ask for it in the proposal rather than at handover.

05

It shipped, and nobody used it

Fault: Yours

The hardest failure to blame on engineering. If the users were not consulted before the build, the build cannot fix it — and no partner can run that conversation for you, though a good one will tell you it is missing.

06

It passed the demo and failed the first security review

Fault: Theirs

Tenant isolation, scoped access, an audit trail, and a written answer on where customer data goes are architecture, not paperwork. Retrofitting them costs multiples of building them, and the deadline is set by your first enterprise customer, not by you.

07

It cost roughly twice the estimate

Fault: Shared

Usually two things at once: an estimate made against a scope nobody had finished, and a buyer who preferred the lower number. The defence is a small paid piece of scoping work before the big commitment, priced so that being wrong is cheap.

08

You could not hand it to your own team

Fault: Theirs

Code that only its authors can run is not finished, whatever it does in production. If a proposal has no handover artifacts in it, the handover is not planned, and the retainer that follows is not a service — it is a dependency.

6

Times you should not hire an agency at all.

This is the section a page like this normally leaves out, and it is the reason the rest is worth reading. Every one of these is business we would decline or lose, and every one of them is real.

  • 01You cannot describe the outcome in one sentence yet. Talk to ten of your own users first; no vendor can do that for you, and several will happily bill you while you work it out.
  • 02The software is the company. Core, permanent, differentiating IP is worth a hiring cycle and the decade of salary behind it.
  • 03You need it maintained for years by people you employ. A partner can build it and hand it over properly; it should not quietly become your engineering department.
  • 04You already have an engineer who could do it and is asking to. Buying around your own team is how you lose them, and they were the cheapest option.
  • 05Your budget covers the build but not the running of it. Software with no operating budget is an expensive way to produce something nobody can keep alive.
  • 06You are shopping on the lowest hourly rate. The market clears; a rate far below it is subsidised by something, and it is usually the seniority of whoever actually turns up.
Run it on us

We are one of the firms you would be evaluating. Here is where to check.

Four places on this site exist to answer the criteria above, and one criterion we cannot answer. We are not going to tell you we are the top SaaS development company — that is not a claim anybody can make about themselves, which is the whole argument of this page.

The criterion we fail in public

A significant share of our work is delivered through other agencies, under their brand — and we cannot show you any of it. Those engagements sit under the same non-disclosure we would sign with you, and we do not ask partners for permission to publish their clients. Put it this way: if we were willing to publish another client’s work to win yours, we would publish yours to win the next one. What we can show is the direct work, named and open to read, and the specific engineers you would interview before committing.

Questions

What buyers actually search for.

There is no single answer, and any firm that gives you one is answering a different question — how do I win this deal. Fit is specific: a team that has shipped multi-tenant billing and a security review is a poor match for a two-week prototype, and the reverse is worse. So test candidates against criteria instead of a ranking. The seven that matter: the people who scope it are the people who build it; the engagement has a defined end rather than an open discovery meter; they can say what working means as a single number; they will tell you what to cut; the code sits in your repositories from the first commit; they can show something that outlived its engagement; and they price the unglamorous eighty percent, not just the interesting part.

Read who published it. If a development firm published it, it is marketing and the firm is usually on it. If a directory published it, check whether placement is paid — on several of the large ones it is, and the ranking is an advertising product with an editorial voice. Neither is useless, but treat both as a source of candidates rather than a verdict. Beyond Technologies deliberately publishes no such list, including one we would appear on, which is why this page is criteria instead.

Nine, and the useful part is the answer that should worry you. Who exactly writes this code, and can I speak to them this week? What is in scope, and what is the first thing you would cut? What does this engagement have to move, and how will we both see it? Where does the code live, and who owns it on delivery? What happens when the estimate is wrong? Who is on this in month four? What did you last talk a client out of building? What is not included that I will pay for later? And can I see something you shipped that is still running two years on?

A real proposal names the actual people, states what is excluded as clearly as what is included, gives a sequence with dates rather than phases without them, defines done for every deliverable, says who owns the IP and on what date it transfers, names what changes the price and by roughly how much, says what happens if it slips, and lists the handover artifacts — documentation, tests, a runbook. A thin one substitutes a technology list, a headcount of unnamed resources, the word agile, a phase table with no dates, one lump sum, and testimonials where deliverables should be.

Ask what they would remove from your scope. A bluffer agrees with all of it, because agreement closes deals and every removed feature is removed revenue. A builder has an opinion within ten minutes, names the two things that carry the product, and can tell you what the removed features would have cost to maintain. Then ask what they last talked a client out of. No example means nobody has ever trusted them enough to hear it — or they have never been willing to say it.

In-house wins when the thing being built *is* the company: core, permanent, differentiating software worth a hiring cycle and a decade of salary. An agency wins when the work has a defined end, when the skill is needed now and not forever, or when your own team is the constraint rather than the plan. There is a real hybrid: an agency builds the first version and hands it to the in-house team that gets hired while it is being built. What does not work is buying around an engineer you already employ who is asking to do it.

Six cases. You cannot yet describe the outcome in one sentence — talk to ten of your own users first, nobody can do that for you. The software is your core, permanent differentiator. You need it maintained for years by people you employ. You already have an engineer who could do it and wants to. Your budget covers the build but not the running of it. Or you are shopping purely on the lowest hourly rate, which is always subsidised by something, usually the seniority of whoever actually turns up.

Duration is an output of scope, not an input, so a firm that answers this before hearing the scope is guessing at you rather than at the work. What you can hold them to is shape: a named capability with a defined end, not a rolling engagement. For reference, our own named engagements are deliberately short — a two-week readiness assessment, a three-to-six-week integration sprint, an eight-to-twelve-week rescue of a build that stalled before production. If a proposal cannot be cut into pieces that size, the scope is the problem, not the calendar.

Let's put AI to work in your business.

A 30-minute call. You bring the workflow or the roadmap — we'll tell you what's feasible, what it costs, and what we'd build first.

Book a call