Custom software development process: six stages

Our custom software development process has six stages: consultation, signing the contract, interface design, development, testing with fixes, and deployment with training. Each stage ends with something you can check: a quote, a contract, a wireframe, a test version or a working system.

The whole process at a glance

Stage	What we do	What you do	What you get
Consultation	analyse the business problem, recommend a solution, prepare a quote	describe your process and goals	proposed scope and a quote
Contract	write down the requirements, deadline and financial terms	approve the scope	contract with functional requirements
Interface design	prepare a wireframe or screen designs	send us change requests	approved interface design
Development	build the application	answer the team’s questions	version for testing
Testing and fixes	test every feature, provide a test version	try the application on your own data	list of fixes and a version ready to deploy
Deployment	install the application on the server, train your team	provide the user list and the domain name	working system

Consultation and quote

The consultation involves both project leads and developers. A developer can see straight away which ideas are simple and which are expensive to build, and can suggest an alternative. For example, a service company came to us for an order management system and, after the conversation, received a proposal to add online payments and automatic invoicing.

The consultation ends with a proposed scope and a quote. The consultation and requirements analysis before the quote are free of charge. We usually send a quote within 2 business days, and within 5 at the latest. At the same step, we tell you what the application will need on the infrastructure side: a server, backups and security. What drives the price itself is covered in our article on how much a custom web application costs.

Contract and functional requirements

Once we have discussed the details, the deadline and the financial terms, we sign a contract. Its most important part is the functional requirements: the list of what the application should do. The interface design is based on them, and later the tests too, so every unclear sentence in the contract comes back at later stages.

The contract also sets out the acceptance rules and who owns the code. In many projects, the client becomes the legal owner of the code. You choose between a fixed price and time and materials, and payments are split across the stages. Changes of scope after signing are discussed separately, because they affect the deadline and the cost.

Interface design before coding

Based on the requirements in the contract, we prepare a wireframe or an interface design and then refine it with you. A change to a wireframe takes a few minutes. The same change in a finished application can mean rebuilding a form, the database and the tests.

This is the stage where things missed in the contract come to light: who sees which data, what happens when an order is cancelled, how a list with several hundred items looks. It is better for them to surface here.

Building the application

The development team builds the application within the agreed time. We work with the technologies we know from our own projects: Next.js, React, TypeScript, .NET Core and PostgreSQL. We run applications in Docker containers behind an Nginx server, so the test and production environments are alike. The scope of this service is described on our page about custom web applications for businesses.

Your role at this stage is smaller, but not zero. The team may ask about the details of your business rules, for example who approves a quote or what statuses an order can have. A quick answer saves time for both sides.

How do you check that the application works?

When development is finished, we test every feature of the system. Then you get access to a test version of the application, check whether it meets your expectations and send us change requests.

A few tips that shorten this stage:

• test with data similar to real data rather than entries like “test1” and “test2”,
• go through the whole process step by step, in every user role,
• keep a single list of comments, describing what you did and what you expected,
• tell bugs apart from new ideas, because new ideas belong in the next stage.

Deployment and training

We install the finished application on the target server, connect your domain and set up an encrypted connection with an SSL certificate. After deployment, we train your team to use the system. As part of maintenance, we provide technical support and database backups.

Deployment is not the end of an application’s life. Libraries get security updates, users come up with ideas and the business changes. That is why maintenance is worth discussing at the consultation, before the first problem appears.

Who on your side should be involved in the project?

Projects work best when the client side covers three roles. Sometimes one person fills all of them.

• The decision-maker approves the scope, the wireframes and acceptance. Without one, every question waits for a board meeting.
• A future user, someone who runs the process day to day, is the quickest to spot that a screen does not fit the work.
• A technical contact manages your domain name and has access to the server, or is in touch with the company that runs your IT. This person helps at deployment.

If your company has no one in IT, the Conetso Group team can look after the infrastructure under the application. Conetso Software is the software development team of Conetso Group, based in Lublin, Poland. What matters is that it is clear from the start who makes the decisions and who tests.

An example from our projects

The booking system for diagnostic scans was built for a private clinic, to its requirements. Its first version runs on its own, without integrations with the clinic’s other systems. You will find more projects in our portfolio.

The first step is a consultation. Describe your idea and we will arrange it.