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.
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
Task
You describe what should come out and for whom. We ask questions.
Requirements and prototype
We write down the requirements and show a prototype. You correct it before development starts.
Development
We build the product to the agreed requirements.
Testing
We check it against the scenarios from the requirements.
Launch
We launch on your command.
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 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
| Direction | What it covers |
|---|---|
| Mobile and web apps | An app for customers or staff, from a first version to later growth |
| SaaS and account areas | A subscription service or customer account area with user accounts, roles and user data |
| Internal tools | Reports, request forms and data exchange between systems in place of manual work |
| Management systems | A custom system built around your processes: clients, orders, documents, reports and staff roles |
| Integrations | Linking your systems and services to one another |
| MVPs and prototypes | A first version or a clickable mockup to test an idea |
| Work on an existing product | Fixes 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:
- 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.
- 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.
- Development. We build the product to the agreed requirements, in parts, so you see intermediate results.
- Testing. We go through the scenarios from the requirements and keep a list of what we find.
- Launch. The product goes live when you say so.
- 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 service | Freelancer | Team under contract | |
|---|---|---|---|
| When it fits | The task is standard and ready-made features cover it | A narrow task with a clear scope | Several parts, integrations and further development |
| What sets the limits | The service's features and terms | The agreement with the freelancer | Requirements, stages and the contract |
| Find out first | What happens if the service changes its terms or shuts down | Who extends the product afterward | Which 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.