Software

Custom app and SaaS development: an audit first, code second

You describe the task, we record the requirements and a prototype before development begins, then development, testing, launch and support. We send a preliminary proposal with an approximate timeline after the analysis, then a contract.

Choose a serviceHow we work

What you can order

  • Mobile and web apps

    An app for your customers or staff, from a first version onward.

  • SaaS services and customer accounts

    A subscription service or a customer account: sign-in, roles, user data.

  • Internal business tools and automation

    Records, requests, reports, moving data between systems: what is done by hand now.

  • Integrations

    We connect your systems and services to each other.

  • MVPs and prototypes

    A first version or a clickable prototype to test an idea before big development.

  • Rework and support of existing software

    Fixes, new features and maintenance of a product that already runs. Terms depend on the state of the product.

Who it is for

  • An idea or product owner

    You have an idea for a service or an app and need to estimate the scope and build a first version.

  • A company with manual processes

    Part of the work lives in spreadsheets and chats and should move into one tool.

  • A company with an existing product

    It needs rework, connection to other systems or ongoing support.

  • An agency client

    The site, ads and analytics are already with us, and now you need a service or an account tied to them.

How the work goes

  1. Task

    You describe what should come out and for whom. We ask questions.

  2. Requirements and prototype

    We write down the requirements and show a prototype. You correct it before development starts.

  3. Development

    We build the product to the agreed requirements.

  4. Testing

    We check it against the scenarios from the requirements.

  5. Launch

    We launch on your command.

  6. Support

    We fix errors and develop the product. [FILL IN: support terms]

What you get

  • The product and documentation for the agreed scope

    What exactly is included is fixed in the requirements and the contract. [FILL IN: documentation that is handed over]

  • Source code and access

    The terms are set out in the contract.

  • A report by stage

    What was done, what was checked, what is next.

What we need from you

A description of the task and goals, and who will use the product. Access to the systems that need integration. A person who decides on requirements and accepts the result. Brand materials, if the interface needs them. We need your feedback at every stage: timing depends on it.

Platforms and technologies

We choose the platform and technologies by the task and who will maintain the product. We discuss the choice with you before development starts and record it in the requirements. [FILL IN: technologies and platforms the studio works with, if they may be named]

Data and legal questions

If the product holds user data, you need to decide where it is stored and how it is processed. [FILL IN: data storage terms, legal texts for software (policy, user agreement, consents)] [FILL IN: lawyer — jurisdiction and applicable law]

What we do not promise

We do not promise user numbers, revenue or growth: that depends on the market and the product. We name specific timelines in the contract, after the final approvals. Examples of work: [FILL IN: software portfolio, if any].

A cube of glass modules with one module glowing orange, encircled by a ribbon loop
A system of modules, each in its place

A wish like "I want what they have, but ours" still has to become a task. Before any code, we spend time on three questions. What work should the program take on? Who will use it? What happens if it is never built? The answers become an audit, and the audit becomes the requirements behind the whole build.

When a custom build makes sense

  • You have a concept for a service or app, but cannot say what the first version should contain.
  • Records, requests or reports live in spreadsheets and chat threads, and it is time to bring them together.
  • You own a working product that you want to extend, connect to other systems or hand over for support.
  • An idea deserves a prototype before a large budget is committed.
  • The site, ads and analytics are already set up, and now you need an account area or service tied to them.

What you can order

DirectionWhat it covers
Mobile and web appsAn app for customers or staff, from a first version to later growth
SaaS and account areasA subscription service or customer account area with user accounts, roles and user data
Internal toolsReports, request forms and data exchange between systems in place of manual work
Management systemsA custom system built around your processes: clients, orders, documents, reports and staff roles
IntegrationsLinking your systems and services to one another
MVPs and prototypesA first version or a clickable mockup to test an idea
Work on an existing productFixes and new features, after a look at what is already there

Why we do not name the tech stack up front

The name of a programming language or platform says little without a task behind it. The choice depends on three things. One is where the product will run: a phone, a browser or both. Another is which systems it connects to. The last is who will maintain it later. After the audit we propose options and explain the difference in plain words. The decision is written into the requirements and agreed with you before development starts.

Stages after the contract

The steps up to signing are on How we work. The software brief adds its own questions: what the result should be, who it is for and which systems it touches. Then:

  1. Audit. This is a separate paid stage; its scope and terms are recorded in the preliminary proposal. We examine the task or, if a product exists, its condition: what works, what gets in the way, what we can access. We ask how people do the job today, how often, and what happens when something goes wrong. The outcome is a description of the task and a sense of scope, not a figure offered on the spot.
  2. Requirements and prototype. We write down the user roles and what each role can do. We also record the data the program handles, the links to other systems and what stays out of the first version. A prototype follows from that text. Changes are easier to agree on at the prototype stage than later.
  3. Development. We build the product to the agreed requirements, in parts, so you see intermediate results.
  4. Testing. We go through the scenarios from the requirements and keep a list of what we find.
  5. Launch. The product goes live when you say so.
  6. Support and growth. We fix errors and add features. We agree the support terms in advance.

From you we need a description of the task and goals, access to systems for integrations, and brand materials where the interface uses them. We also need one person who decides on the requirements and accepts the result. Timing depends partly on how fast your answers arrive at each stage.

What you hold after each stage

User numbers, revenue and product growth cannot be promised: the market and the product itself decide them. What we show is work that was done and tested against the approved requirements:

  • Task description and requirements. A document you approve before development begins. Acceptance follows it.
  • Prototype. A mockup showing how the first version will look and behave.
  • Report by stage. What is ready, what was tested, what comes next.
  • List of findings. What turned up in testing and what has been fixed.

Build your own or use something ready-made

A custom build is justified when:

  • ready-made services leave the task uncovered or do not connect to your systems;
  • you can describe requirements and accept work stage by stage;
  • the product is meant to evolve rather than stay a one-off page.

Choose something else when:

  • a subscription service already solves it, so there is no reason to write your own;
  • all you need is a website or a page for ads: see Websites and Landing pages;
  • the task is not formulated at all: start with the brief, and the audit and prototype will help outline it;
  • you need sales as a service: we do not offer that.

Subscription, freelancer or team under contract

Subscription serviceFreelancerTeam under contract
When it fitsThe task is standard and ready-made features cover itA narrow task with a clear scopeSeveral parts, integrations and further development
What sets the limitsThe service's features and termsThe agreement with the freelancerRequirements, stages and the contract
Find out firstWhat happens if the service changes its terms or shuts downWho extends the product afterwardWhich rights, access and support are fixed

Questions and answers

What do I get after the audit?

A description of the task, requirements and a prototype that the rest of the work follows. The scope and terms are set out in the preliminary proposal.

Where do I start if I only have a concept?

Start with a request. The software brief has its own questions about the task, the users and the connected systems. Describing the concept in your own words is enough. We work out the rest during the audit.

Do I have to choose the technology myself?

No. After the audit we propose options and explain how they differ for you: who can maintain the product and what happens if the contractor changes. The choice goes into the requirements.

Can you take over a product built by someone else?

Possibly. A paid audit comes first: we look at the product's condition and access to the source code, then name the scope and terms.

Who owns the code, and how is support arranged?

Rights to the source code, access, the order of support and the handling of user data are set out in the contract.

What connects to a custom build

Have a task for an app or a service?

Leave a short request: we will send you a link to the brief. From your answers we will prepare an analysis and a preliminary proposal.

Choose a service