Back to blog
Apps & automation

How to choose a company to build a web application? Software house, freelancer or no-code

Published: 2026-11-0213 minKrzysztof Jaroński

A company ordering a web application often compares three worlds: a software house, a freelancer and a no-code tool. Each promises a “panel”, “user accounts” and an “integration”. The difference shows up later: who delivers the second stage, who answers six months after launch, and whether the code stays with you.

How to choose a company to build an application is a different question from hiring someone for a company website. An application runs a process: roles, data, exceptions, connections to other systems, and life after the first release. A website mainly presents an offer and collects contact.

If you need a site rather than a system, start with how to choose a website contractor. This article is for people ordering an application or a web system.

Choosing an app vendor is not the same as choosing a website vendor

With a website you can often judge the result from a few pages, the layout and whether it is comfortable to use. With an application the first screen says little. What matters is whether a staff member can finish their work, whether a customer sees only their own data, and what happens when an outside system does not answer.

A portfolio full of pretty mockups is a weak argument. A mockup does not show permissions, a migration of old data, or who fixes a bug on a Friday afternoon. A web application vendor should be able to talk about a working product: who uses it, which process replaced a spreadsheet or email, and what remained after launch.

In web application work the vendor decision lasts longer than a one-off site. The system will grow. New roles, a new report, a new connection to a tool the company already uses. You want to know whether the same person or team can carry that growth, or whether you are left with code nobody wants to touch.

Before you compare figures, decide what you are actually buying. The comparison of a web application and a website helps. If you need accounts, statuses, several roles or an exchange of data with another program, you are on the application side. Criteria from the website market — page count, template look, speed of a brochure site — stop being enough.

Software house, freelancer or a no-code tool

There is no single right choice. There is a choice that fits scale, continuity and risk.

A software house makes sense when the process matters to the company, there is more than one role, and integrations are not “if we manage”. A team gives continuity: one person’s holiday does not stop the project, and after launch there is someone to talk to about the next stage. You pay for that continuity. In return you get a split of work and someone who can pick up the topic when the original author is away.

A freelancer can be a good web application vendor for a narrow scope: one team, one main path, few dependencies on the outside world. The risk is different. All the knowledge sits in one head. Illness, another contract or the end of the cooperation leaves you with a repository nobody in the company can enter. That does not disqualify a freelancer. It disqualifies an arrangement with no handover plan.

No-code is enough at the start when the process is simple, there are few users, and ready-made blocks cover what actually has to be done. The limit appears with unusual logic, a large number of exceptions, and connections the tool did not foresee. Then a “quick start” becomes a fight with limits. No-code is an honest prototype, or a permanent tool, only when you accept those limits on purpose.

Look at four things together:

  • scale — how many people and sites will use it;
  • continuity — whether the project should live for a year or only until a presentation;
  • number of roles — one “user” role is different work from customer, staff and admin;
  • integrations — whether the system must talk to tools the company already uses.

Software house or freelancer is not a question of prestige. It is whether you can carry the risk of a single person. No-code is not a “worse application”. It is a different contract: faster at the beginning, tighter later.

What to check in a portfolio

Ask for the address of a working application, not a slide. Open it yourself. Create a test account if you can. Click the path the vendor calls the main one. See what happens on an error: a human message, or “something went wrong” with no next step.

Live production applications matter more than mockups. Production means someone uses it on an ordinary day, not only in a demo. Ask whether that application is still being developed and who receives reports. A project abandoned after handover says more than three concepts in a design file.

Integrations with outside systems are worth seeing in a description, not a slogan. “We connect to a CRM” says nothing. Better: which event goes out, what comes back, what happens when the other side does not answer. If the portfolio has no such case and your process depends on it, that is a gap, not a detail.

Care after launch is tested with one question: does the vendor still look after their own projects. Someone who hands over the code and leaves can be the right fit if you agreed a handover from the start. Someone who promises care but cannot point to a product still alive after launch is telling a story you cannot check.

For us that reference point is BeautyBoost AI (beautyboostai.pl). It is our own web application, running in production: an AI assistant for beauty salons. It replies in Instagram DMs, Messenger and a widget on the site. It books visits in Google Calendar or Outlook. It collects leads and runs an automatic follow-up. It serves many salons on separate accounts and subscription payments. I give this as an example of a product that did not stop at a mockup, not as a template scope for every job. Your process will be different. The point is that a vendor should have something to show besides a presentation.

Questions for the first meeting

The first meeting is not for admiring technology. It is for checking whether the person understands your work. A list worth having:

  1. Which process should this application replace, and who does it by hand today?
  2. How many roles do you see in the first version, and which do we defer?
  3. Which systems must it talk to on day one, and which can wait?
  4. Where does the starting data come from, and what shape is it in?
  5. Who on our side accepts the scope and receives each slice?
  6. What does the first version look like that people can actually work in, not only watch?
  7. Who owns the code and the repository on handover day?
  8. Where will the application live, and who pays for that place?
  9. How do we report fixes after launch, and in what rhythm do you return to further work?
  10. What are you deliberately not doing in the first version?

A good conversation ends with a narrower scope than a wish-list brief. A weak one ends with a promise that “everything can be added”. The questions are not there to catch jargon. They show whether the web application vendor asks about exceptions or jumps straight to screens.

How to read a quote

A quote without a list of what is inside cannot be compared with another quote. Look for these blocks.

Scope and MVP. What the user does in the first version from entry to result. What is named as a later stage. If both offers say “panel” and only one spells out roles and one process, they are not the same offer.

Out of scope. An honest quote says what it does not include: a history migration, an extra language, a report “like the spreadsheet”, another integration. Without that list the extra cost appears halfway through.

Care after launch. Whether there is a fix window, ongoing care, or silence. Care is not a gift. It is time for updates, small fixes and someone who knows this code.

Ownership of the code and the repository. On handover day you should know where the code sits, who can access it, and whether you can invite another vendor. That is a business decision: you keep a product, or a subscription to someone else’s black box.

Hosting and who pays for it. The application lives somewhere. The bill can sit on your account or be included in care. Both are fine if they are named. It is bad when nobody knows whose card it is and what happens when the cooperation ends.

Documentation and handover. A short note: how to run it, where the access lives, how to report a bug. Without that the next person starts from zero, even if the code is yours.

More on what drives cost — without figures — is in web application pricing: what affects project cost. How to shape the conversation before you compare figures is in how much a web application costs. When you read offers, stay with that list, not with the single number at the end.

Red flags

A few signals are worth taking seriously before a deposit moves.

  • A quote with no questions about the process. If nobody asked who clicks, where the data comes from and what the exception is, the figure is a guess.
  • No access to the repository. A promise that “the code is ours” without an invitation to the repository leaves you without a copy you can take.
  • “Everything in the first version.” A full wish list in one pass usually ends in delay, or in a quiet cut you did not decide.
  • No care plan. Launch without agreeing who fixes bugs in the first month means firefighting by email: “are you still working”.
  • Code only on the vendor’s server. You have no copy, no history of changes, and you cannot ask someone else to quote further work.
  • A demo instead of a path. A handsome sign-in screen and nothing after it: no role, no empty state, none of what a staff member does every day.

A red flag is not an argument in the meeting. It is a request to write the gap into the offer. Someone who can write it in can usually deliver it. Someone who waves it off as “that’s standard, don’t worry” keeps the standard in their head, not in the contract.

What cooperation looks like after launch

Launch day is not the end. Small friction appears: a label, a missing field, a report nobody asked for in the brief and without which a manager cannot close the week. That is normal. It is not normal when nobody knows where to report it.

Agree four things beforehand. Fixes — what belongs in the first weeks after launch, and what is a new feature. Updates — who keeps the tools underneath from staying on last year’s version. Further development — in what rhythm you return to the next slice, instead of collecting wishes forever. Access — who has an account for the repository, for the place where the application lives, and for the tools it connects to.

The way you report can be simple: one place, a short note of what should have happened and what did happen. What matters is that there are not five channels, none of which is “the official one”.

I describe the build itself, from idea to the first version, separately: what building a web application looks like from idea to launch. Choosing a company and running the work are two conversations. People and rules first, stages second.

Checklist before you sign

Before you sign, tick the points. If one is missing from the offer, add it or defer it on purpose.

  • We know which process the first version handles and who uses it.
  • We know which roles are now and which are later.
  • We know which integrations are in this stage.
  • We know where the starting data comes from.
  • We know what is out of scope.
  • We know where the repository will be and who gets access.
  • We know where the application will live and who pays.
  • We know how to report fixes after launch.
  • We know whether there is care after launch or a handover.
  • We have a short note on how to run the project and where access lives.
  • We compared offers by scope, not by a single figure.
  • We have a person on our side who accepts each slice.

This list does not replace a contract. It organises the conversation so a “detail” does not stay off the paper. If two offers look different after the ticks, only then does the figure start to mean something.

FAQ

Software house or freelancer for a web application?

A software house gives continuity when there are more roles and integrations and the project should live after the first version. A freelancer fits a narrower scope if you have a handover plan in case the cooperation ends. The choice depends on the risk of a single person, not on the name on a card.

Is no-code enough to start?

It is enough when the process is simple and ready-made blocks cover the real work. It stops being enough when unusual logic, many exceptions or connections the tool does not support appear. Treat no-code as a deliberate start, not as a promise that you will “somehow move later” at no cost.

Who should own the code and the repository?

You should, unless you knowingly buy a closed service and accept that you cannot move on without that vendor. The owner is the one who can invite another specialist and take a copy. Agree this before the deposit, not at the breakup.

How long does choosing a vendor take, and where do you start?

As long as it takes to write down the process, the roles and the integrations, plus two or three conversations with people who ask questions instead of quoting a “panel” immediately. Start with what a staff member does by hand today. Without that, every offer is a guess.

What should a web application quote include?

A first version people can use, a list of what is out of scope, care after launch, ownership of the code and the repository, where it runs and who pays, and a short handover. One number without that list cannot be compared with another number.

Summary and next step

How to choose a company to build an application comes down to a few checks: whether the portfolio is a living product, whether the quote names the scope and what it leaves out, whether the code stays with you, and whether there is someone to talk to after launch. Software house, freelancer or no-code follows from scale and from the risk you accept. Not from fashion.

If you want to discuss your own process, see web application development for businesses or write via the contact form.

Related materials