Custom software development: plan, cost and choose a team
Custom software goes well when the first release is small, the quote follows a paid discovery, and the code sits in your own repository from day one. The steps from idea to first release and after, with my positions on each.
On this page
- Do you actually need custom software?
- How do you write a scope a team can quote?
- Should you pay for a discovery phase first?
- How do you estimate what custom software will cost?
- Fixed price or time and materials?
- How do you choose a development team?
- What should the build phase look like?
- Who should own the code and accounts?
- What does a proper handover include?
- What happens after the first release?
- Frequently asked questions
Custom software development goes well when three things are true before anyone writes code: the first release is small enough to ship in a few months, the price is set after a short paid discovery rather than before it, and the code, accounts and servers are in your company's name from day one. Get those right and most of the usual horror stories don't happen. This guide walks through each step from idea to first release and the year after, with the positions I hold and why.
It's written for business owners and managers commissioning a web app, portal, internal tool or mobile app from an outside team. If you're hiring your own developers to build a product in-house, the scoping and ownership sections still apply, but the contract sections won't.
A note on our interest: Cloudgramam builds web applications, websites and mobile apps for clients, so I have a stake in you deciding to build. Where an off-the-shelf tool fits better, I'll say so below. Hosting, app store accounts and third-party services are paid by you to the providers; we charge only for our own work. Facts linked here were checked on 16 November 2026.
Do you actually need custom software?
You need custom software when the way your business works is the advantage, and every off-the-shelf tool forces you to work like everyone else. If a subscription product does 80% of the job and your team can live with the rest, buy the subscription.
I ask one question first: what do you do today that no tool supports? If the answer is a spreadsheet passed between three people every morning, that's a real gap. If the answer is "we want our own branding", it usually isn't, because most good tools let you brand them.
There are honest middle paths. A no-code builder gets a marketplace or directory live quickly, and the post on what you give up with no-code marketplace builders explains whether those limits matter. For online selling, a Shopify theme often beats a custom build; the trade-offs are in Shopify theme or custom development. And for a marketing site, a website builder is often right, which I cover in custom website or a website builder.
Custom starts to pay off when the rules are particular to you. A distributor with customer-specific price lists, credit limits and reorder flows is a good example, and what a B2B catalog platform needs that a regular ecommerce site does not shows how quickly those rules pile up.
How do you write a scope a team can quote?
A scope a team can quote describes who uses the software, what each of them must be able to do in the first release, what data it holds and which systems it talks to. It doesn't need to describe screens or pick a tech stack.
Here's the structure I ask clients to fill in before a first call. One page is enough.
- The problem in two sentences, in your own words.
- Each type of user (customer, field staff, manager, admin) and what each must do.
- A "must have for release one" list and a separate "later" list. The second list matters as much as the first.
- The data: what records exist, roughly how many, and where they live today.
- Every system it connects to, such as accounting, ERP, payments, Microsoft 365 sign-in or WhatsApp, with a note on whether data flows one way or both.
- Any hard date and the reason for it.
Integrations are where scopes go wrong most often. "Connect to our ERP" can mean a nightly export file or a live two-way sync with error handling, and those differ by weeks of work. Write down which one you mean.
Should you pay for a discovery phase first?
Yes. A short paid discovery, usually a few workshops and a written scope, is the cheapest way to turn a vague idea into a price you can hold someone to. Any fixed price given before it is a guess with a number attached.
On our own projects, a fixed quote comes after a requirements workshop or, for an existing system, a code review. For mobile apps the discovery also produces a clickable prototype, so you can tap through the main screens before you commit to the build. You keep the written scope even if you take it to another team, and I think that's the test of a fair discovery: the output should be useful to someone else.
How do you estimate what custom software will cost?
Cost is hours multiplied by a rate, plus the running costs you'll pay to providers. Ask every team to show the hours per piece of work, because a single total hides where the risk sits.
A useful estimate breaks into lines like discovery, design, front end, back end, each integration, testing, release and project management. Here's the method with made-up inputs. Say discovery is 40 hours, the build lines add up to 600 hours and testing is 90 hours. That's 730 hours. At an example rate of R per hour, the build costs 730 × R. Swap in the rate from the quote you're holding; I'm deliberately not giving a market rate, because rates vary too much by country, seniority and team size to be useful as a single number.
Then add what you'll pay others every month: hosting in your own cloud account, email sending, maps, SMS, app store memberships, error monitoring. These are small next to the build but they never stop. For a worked mobile example with the Apple and Google fees, see mobile app development cost in India.
Timelines from our own service pages give a sense of scale: small web applications and APIs usually take six to twelve weeks, a focused first version of a mobile app eight to sixteen, and a multi-vendor marketplace three to six months for a first release. Bigger than that, and I'd cut the first release down.
Fixed price or time and materials?
Choose fixed price when the scope is written and stable, and time and materials when you expect to change direction as you learn. Neither is safer by default; each moves a different risk onto a different party.
| Situation | Better fit | Why |
|---|---|---|
| Discovery done, first release written down, few unknowns | Fixed price | You know the total before you start; the team carries the estimation risk |
| A new product where you'll learn from early users | Time and materials, capped per month | Changing course doesn't need a contract change each time |
| An old system nobody fully understands | Fixed-price review, then either | Nobody can price unknown code honestly until someone has read it |
| Ongoing fixes and small features after launch | Monthly plan | Work arrives in small pieces, so a quote per piece wastes everyone's time |
| You need extra developers inside your own team | Monthly dedicated developers | Your team sets the priorities; you pay for capacity |
The trap with fixed price is the change request. Take an illustrative project: a booking portal quoted on a written scope, and in week five the client asks for a second price tier for repeat customers. Small on its own. But it touches the checkout, the invoices and the admin reports. Under fixed price that's a change request with its own estimate, and if nobody agreed how change requests work, it becomes an argument. My fix is boring and it works: agree in the contract that changes are estimated in hours at a stated rate before work starts, and that anything on the "later" list stays later unless something of similar size comes off.
The trap with time and materials is drift. Cap the hours per month, and ask for a demo of working software every two weeks, so you can see what the hours bought.
How do you choose a development team?
Pick the team that asks you the most specific questions about your business and shows you the most specific answers about their process. Portfolios matter less than how they handle the parts that go wrong.
Questions I'd ask any team, including mine:
- Will the code be in a repository my company owns, from the first commit?
- How often will I see working software I can use myself, on my own phone or laptop?
- Who exactly works on my project, and what happens if one of them leaves?
- How do you handle a change I ask for halfway through?
- What does handover include if I move the work in-house later?
- What's your test process before a release reaches my users?
Then the stack. A team should explain its technology choice in plain terms and say when a different stack would suit you better. I've set out how I compare Node.js, Python, PHP, .NET, Java and Go in choosing a back-end for your project. The short version: the stack matters less than whether you can hire for it in five years.
What should the build phase look like?
A healthy build delivers working software every two weeks, on a test server or a test build on your phone, and you accept or reject each feature against the written scope. If you go a month without seeing anything run, ask why.
Name one person on your side as product owner. Their job is to answer questions within a day or two and to approve screens. In my experience, projects slip less from slow developers than from a question waiting a week for an answer.
Testing belongs inside each two-week cycle, not at the end. Ask to see real data in the test system early, because a customer list with 40,000 rows behaves differently from the ten test records the team typed in.
Who should own the code and accounts?
You should. The code repository, cloud account, domain, app store developer accounts and payment provider accounts should all be in your company's name, with the team given access that you can remove. That's how we set up every project, and I'd walk away from a team that wants to keep any of these in its own name.
Ownership is more than a clause. Check these on day one, not at the end:
- The repository sits in your GitHub, GitLab or Azure DevOps organisation.
- Servers run in your own AWS, Azure, Google Cloud or VPS account and the bill comes to you. We don't resell hosting.
- Apple and Google developer accounts are opened in your company name. Apple asks organisations for a D-U-N-S Number and a working website on your own domain, per its enrolment page, so start that early.
- The contract assigns the copyright in the code to you on payment. Have your lawyer word that part.
If the project also involves moving staff to Microsoft 365 for sign-in or email, treat that as its own piece of work with its own plan; our Microsoft 365 migration checklist covers the order of steps.
What does a proper handover include?
A proper handover lets a new developer, who has never met the original team, set the project up on a laptop and release a change within a day or two. Anything less means you're still tied to the people who built it.
That needs a README with setup steps, a list of every environment variable and where its value lives, the deployment pipeline written as code, a note on each integration and its credentials owner, and the database migration history. I ask for a dry run: someone outside the build team follows the README while the original team watches and stays quiet. Gaps show up in the first hour.
What happens after the first release?
After release, software needs regular work just to stay where it is: security patches, framework upgrades, operating system changes for mobile apps, and fixes for real-world use you didn't predict. Budget for it from the start, as hours per month.
Runtimes have published support windows, and they end. A Node.js LTS release gets critical fixes for about 30 months in total, per the Node.js release page, so an app built today will need at least one major runtime upgrade in its first three years. Mobile apps have a yearly cycle of their own, set by Apple and Google.
Growth brings different problems from launch. The things that break when a platform gets busier are rarely the ones you planned for; what breaks in a marketplace platform once you pass 50 vendors is a good picture of that, even if you aren't building a marketplace.
Plan the second release from usage data, not from the "later" list alone. Some of that list will turn out not to matter once real people use the first version.
Frequently asked questions
How long does custom software take to build?
It depends on scope, but as a guide our service pages quote six to twelve weeks for small web applications and APIs and eight to sixteen weeks for a focused first mobile app. If an estimate runs past six months, cut the first release.
Can we start with a web app and add a mobile app later?
Yes, and it's often the cheaper order. Build the back end as an API from the start, and a later mobile app can use the same data and rules. Our mobile app development work usually plugs into an API like that.
What if we already have half-built software from another team?
Start with a fixed-price code review. It tells you what to keep, fix or rebuild, and it's the only honest basis for a quote on code someone else wrote.
If you have a written scope, or just the one-page outline above, our Node.js web application team can review it and tell you what a first release could contain. For Microsoft-heavy environments, ASP.NET Core development may fit better, and for existing PHP systems, PHP and Laravel development.