The Custom Business Software Show – Episode 1: The Custom Business Software Development Process

Brett

In this episode you’ll hear our thoughts on:

Inquiries about software
Advertisements for off-the-shelf software
Custom software fitting specific needs
Requirements gathering and design process for building software
Quoting workshop to provide cost and timeframe estimates
Development, testing, alteration, deployment, and documentation time
Cost of time and number of people involved in a software project
Profit margin and expenses for licensing and tools
Prototyping and research for unique software projects
Error handling and catering to various use cases
Retry mechanisms for failed data input
User experience and satisfaction with the software
Ongoing maintenance and updates for software
Outsourcing software development to companies using older technologies and languages
Difficulty in finding developers to maintain older technology
Lack of protection under Australian Consumer Law when outsourcing
Overseas companies posing as Australian companies
Lack of access to source code and accounts when using overseas development companies
Extra cost to rebuild and reverse engineer documentation when using overseas development companies
Importance of clients having access to accounts, source code, and documentation for software development projects
Use of Agile and Scrum methodologies and Kanban boards in software development projects
Factors that can impact the cost of a software development project, including the length of the project, number of developers, and profit margin of the development company
The importance of ongoing maintenance and updates for software
Use of on-demand technical roles such as project managers, CTOs, and team leads
Higher wage costs for in-house senior developers compared to using on-demand support
Lack of support for software developed by other companies
Ability to maintain and support existing software without having developed it
Skills needed to work with unfamiliar code and software
Ad hoc problem-solving and lack of fixed procedures for supporting custom software
Ability to improve and document existing software, and build relationships with clients

So, listen here as we discuss these!

TRANSCRIPT:

Quite often we have people inquire about software.

And they find some ad of the off the shelf out of the box software that they’ve been using.

But it doesn’t quite fit their needs.

They pay a subscription, whether that’s a monthly or yearly subscription, that might be $100 a month.

And then they find, because it doesn’t quite do what I want, maybe they can get their own version built custom, and have it exactly how they want it.

They’re only spending 100 a month.

So maybe if they spend $10,000, they’ll get the exact thing that they want.

Unfortunately, that doesn’t always work that way.

And software is quite expensive to build, the process that we use.

First of all, you’ve got the requirements gathering or talking with the client to understand what needs to be built.

And what do the screens look like?

Whether is it a web application is a mobile application, the screens need to work across different device sizes.

So make sure the screens look good on a mobile device and make sure that they look good on a PC on a tablet.

And so the screens have to adjust in, in the display.

Once we have all the requirements down, that will usually be a pretty high level, we can then go down and do a bit of a design and then a quoting workshop-type arrangement.

And give them a figure on how much we expect it would cost and the timeframe it’ll take this will all factor in development time testing time, fixing any alterations to specs, and deployment time documentation.

And all this obviously takes a considerable length of time.

And I think the key point there is time.

What someone is paying for when software is developed is time and how many people are involved.

So if it’s a six-month project, and three people are working on that full time, you basically have 18 months’ worth of resources that have to be paid for Plus there’s the profit margin on top of that.

Plus, there are the expenses that we incur licensing, for software tools, development tools, any third party subscription applications, all those things, toolkits, that all get factored into the final cost, then there might be some investigation or prototyping processes that happen.

Usually, that would happen in cases where a client comes and says where we’re going to be first to market where we want to build this piece of software that no one else has ever built before.

So it’s a unique piece of software, the problems have never been solved by someone else before.

So when we’re tasked with developing software for that, we have to go out there and do the research and test out how we’ll successfully build it, there might be a few iterations.

So again, that adds to the extra cost.

One of the other big things that a lot of people don’t see, and they’ll probably never see which adds considerable cost is the error handling, error handling.

There are so many different edge cases that need to be handled when you build software.

So a user might input some data into a form.

If they do it correctly.

The software works fantastic.

And it’s really quick to develop.

And it’ll give you the results that you’re looking for.

As soon as someone goes off the beaten track and tries to do something silly, whether that’s on purpose or inadvertently, that’s when the problems occur.

When the problems occur, the person who’s purchased the software still wants the software to run and be robust, they don’t want it to crash, and they don’t want their system to go down.

They don’t want some bad data going into their database, they want everything still to operate and function as it should.

So we need to cater to all the different use cases and all the different ways that a user could interact with the software.

If some data failed to go to a database, that could have been some network outage, or the Internet was down.

We don’t want them just to try once.

So we should accept the user’s input.

If we try and it fails, we may need to implement a retry mechanism for then that retries three, four, or five times.

If after the fifth time, it’s going to fail.

If it’s never going to succeed, then we might need to alert someone that sends emails.

So all this handling adds complexity to the build.

Then you’ve got other things like if you’re interacting with third-party services, whether that might be a different API.

So we want might be sending something to zero or we might be sending something to my OB, that API that we’re using may be limited by how many requests per hour, or how many requests per minute.

And we have to abide by the terms and conditions of the third-party API.

So even if the software we build can take 1000s, and 1000s of requests a minute, we can’t just bond that over to the third party.

So we then have to factor in an additional layer of complexity there to throttle communications.

And again, do the error handling as well.

Another thing that introduces complexity and time and cost is when there’s what we call scope creep.

The client comes with a set of requirements, and then halfway through, they decide they want to make a change.

It’s not exactly how they envisage it, or they had some meetings with their business and decided to take a different path, we may have already started development down one path, and we then have to unpick and change the way it was written.

So we’ve spent time building one thing, got halfway through it, have to undo that make all the necessary changes, and rebuild the new thing.

So we’ve done twice the amount of work.

And that usually comes about when we continually give the user demos of what we’ve built at incremental stages through the development process.

So that’s following the Agile sort of scrum methodology.

So as we build, as we build each iteration, each little feature, once it’s in an operational state, it’s not the full piece of software that’s been shown, but it’s more little features, the user gets to interact and see how it works, what it looks like.

And then once it’s there, and they can see and touch and feel it, they can go Oh, actually, I don’t like that initial idea, I want to change it.

So there are pros and cons we go there and say, Well, you want to this, you know, you want to change it, that’s going to be extra.

But at least we don’t get to the end of the software process.

Here’s the full version.

This is the first time we’ve seen it.

And they don’t like it.

When we go and speak with clients about all these things, and we give them quotes and estimates, quite often the reaction is Well, that’s very expensive, and we can’t afford that.

And then they look overseas.

And they get a quote from an outsourcing company overseas, whether that could be the Philippines could be India or Vietnam, there are quite a few countries that are quite common, and will come back a fraction of the cost.

And quite often we find from our experience that these companies are giving small figures, small-fingered quotes to when the work they may be, they may be naive and not understand the complexity of the software, they may be doing a real shortcut, simplified development cycle, and giving a substandard piece of software at the end.

Or as I said, they may be just trying to win the work.

And then what they’ll say is our this is taking longer than we thought or this is going to be harder than we thought.

So yes, we said it was going to be $30,000.

But now we’re going to need an extra 10.

And we need another 10 and another 10.

And just keep adding to the cost of the software.

The other thing that happens is they don’t change the cost, but it’s more complex than they thought.

And the project just drags for years and years and years we’ve had some inquiries where someone’s going overseas for a cheap piece of software.

And I was told it would be done in six months and two to three years later, it’s still unfinished and the company doesn’t exist anymore.

In these cases, unfortunately, the client has sort of been swindled into paying a small fee for some software they’ve given and been given unrealistic expectations.

They’ve gone ahead with it, the money’s disappeared, they don’t have the quality software that they’re after, and they then have to come back to a more reputable software developer and have it fixed.

So not only do you have to then pay for getting what was already developed, and fixed, but you then have to pay for the next lot of features and to finish off the software.

Sometimes it’s more economical to restart from scratch.

So all that time and money and everything is gone to waste.

Sometimes you can sort of salvage what’s there.

And quite often a lot of the outsourcing companies He’s overseas using old technologies, old languages, old versions of things like Angular or react, and old dotnet versions.

So they’re being they’re getting old, out of date software developed, then they bring it over to Australia, to then maintain it is more expensive because all the developers, most of the developers using the newer technologies, there’s not as many people that are using the older technology.

So finding a developer, to maintain it is harder.

Whether that’s an outsourced local developer, whether that’s just trying to hire someone internally.

So that’s another issue.

Another thing is if you go outsourcing, you’re not so much protected by the Australian Consumer Law.

So when things do go pear-shaped, you don’t have much recourse there.

And one other thing that we’ve noticed is some of these outsourced companies overseas, are putting up Australian fronts.

So they’ll have a website or a company in Australia, and or act and look like an Australian company.

And they’ll quote it quite cheaply.

But all the work will be done overseas.

So in effect, you are still getting the done getting your work done overseas by international developers, I guess the advantage there is that you may have some more protection with Australian Consumer Law.

Unfortunately, when people do come back to us, and they’ll, they’ll say, Well, we’ve been overseas and we’ve had a bad experience.

We don’t have the source code, or the developers have it on their servers.

They’ve been given the final compiled version, which is deployed, but they don’t have the source code to work on.

We have our difficulties so we have to either try and unpick from what’s on the websites that have been deployed or try and reconstruct things.

Again, that’s an extra cost to rebuild that.

There might be limited documentation on how things are deployed, and how things have been built.

So then we have, again, additional costs to then reverse engineer all the documentation for everyone.

There may not be backup scenarios in place, there may not be disaster recovery.

All the accounts might be set up by developers.

And so the actual client doesn’t have access to any of these accounts.

So what we do when we build software is all the accounts that are required, the client will actually subscribe or create them and then grant us access.

That means that therefore in full control, and this is this, the same goes for the source code, that they’ll always have access to their source code.

They’ll also be able to meet the developers, the developers will be able to have one on one conversations through Microsoft Teams zoom, and Google meet, and they’ll have email contact as well.

So they can talk one to one with the developers, and any of the project managers as well.

We’ll also run because we’re doing the Agile and Scrum methodology, we have Kanban boards, these also would be in the possession of the client so that they will even if they were to go somewhere else, they’ve got the full history of all the tasks that were created any communications on those tasks that can hand over to a developer.

And that’s again, another reason why we get them to create all these accounts that if they do decide to leave for whatever reason, they may even just want to hire their own internal developers.

There is a limited handover process, they don’t have to get passwords from us.

They don’t have to worry about getting usernames.

It’s all there for them.

In terms of quotes, a software project, one thing, an easy way to sort of get a ballpark figure is to think what is the average salary for one developer, even if you’re just hiring them as an internal developer.

If we said that that was anywhere between 90 and $120,000.

Then you can look at that and say, well, if my project was going to take 12 months to build for one person, that’s the cost.

Then if you’re outsourcing to an agency, such as Ubisoft, obviously, there’s going to work in a profit margin on top of that.

So you could be easily looking at 150 to $200,000 for a 12-month project for one developer to work on it full time.

When we do build the software, technologies will choose to go to be considered for the type of software that we’re building.

Sometimes it might be PHP, sometimes it might be a dotnet it all depends on the actual software and what we think is best the same thing with hosting whether that would be better on an AWS platform, whether it might be better on an as your platform, or self-hosted somewhere on the client’s own servers.

When we do a front end, the sort of user interface, are we going to do it as a single page app, something similar to like React or Angular?

Or are we going to do it as regular JavaScript and HTML and maybe use jQuery?

All of these things factored into the cost, but also for ongoing maintenance, which is very important.

And the technologies that we choose, one of the main, one of the big driving factors is can we get developers ready to support that?

Technology?

So not just for our own benefit?

But for the client’s benefit in that if they need it?

Even if they wanted to hire their own staff?

Can they put an ad on seek or indeed, and reliably get someone to do it?

And for us, obviously, if we need to ramp up or if we had a staff turnover?

How easy is it for us to get a replacement to get up and running pretty quickly and continue the development of that software?

So in summary, yes, custom software is going to be an extremely expensive process and an expensive journey to go on.

But by getting it completed by Qubisoft locally, you’ll get a personalized experience one on one with the developers, and the project managers, we can meet in person, we have an office in Adelaide, and offices in Melbourne, and we can travel out to your offices and meet you on-site, we can provide on-site support, it will feel like the development team is part of your in your own organization.

And the relationships are intended to be long-term.

And the software that you do get built should be considered and treated like an asset of your business.

So it’s not something that is thrown away, it’s going to enhance your business, it’s going to streamline it.

So it may cost.

Let’s say it costs you $200,000 You may get you should be looking to get more than $200,000 worth of benefits with it, whether that’s through reduced salary or diverting workers to do things that in your business that weren’t being attended to, once a piece of software has been developed, whether that’s by us or by another developer, and it’s actually live within a business.

It’s not a set-and-forget type scenario, the software has to be maintained and supported for the life of that software while it’s in the business.

And it’s while it’s being used.

So support activities might be upgrading libraries to newer versions and fixing bugs, adding small features or larger features that are missing at the time of deployment.

There might be some access issues, so users maybe forgot their password and can’t get in anymore.

There might have been a security breach.

We need might need data backups and all sorts of different things that need to occur.

And I think a lot of businesses seem to forget that this is the case that once software has been developed, it is an ongoing investment.

And they need to consider these different things.

So that’s one service that we do offer is that we do offer a monthly software maintenance service and support service.

This is usually a fixed cost per month, which gives you a number of hours allocated to that client where we’ll have developers available to work on any issues that are raised.

It might be even that they want some documentation created.

The minimum we do is 10 hours per month at a fixed rate.

When we were discussing this at our last Planning Day, one developer actually brought up a really good term that we could use as a product offering and that was software insurance.

The reason why we came up with this term or this developer came up with this term was basically we have some clients who actually pay the ongoing fee but they don’t actually for the whole month don’t actually engage our services or literally is them putting aside a small amount of money each month to us in case something happens so that they’re not alone that if something does blow up or if they do need help or they have to ask a question there is someone to call on the sort of like a phone a friend option.

And this is particularly important when they don’t have there in-house developers or they may have some in-house developers, but the actual team is quite small.

So it’s a common scenario where a business might have one or two, maybe junior developers or intermediate developers, in which case that keeps their wage costs down.

But they can do most of the technical tasks in-house.

But when they need some more expert help or some advanced support, then they don’t have to have an in-house.

Senior Developer they can call on us, to support it in that way.

So from that point of view, we’re also looking to provide that on-demand project manager on demand, CTO, a chief technical officer demand team lead those sorts of roles where if you were to hire someone, a dedicated person full time in the house, then you could be looking at upwards of 150 to $200,000 in salaries.

Whereas someone might not need a fully dedicated person for that within their business, they still need some reliable advice from that kind of person.

And that’s where I think we can step in and do that.

supporting other people’s software, it seems like it’s a niche market, and a lot of people or a lot of other software businesses do.

It seems like when we get inquiries to support existing software, we find out that they’ve tried contacting other software developers, and they don’t do it, or that they’ll only support those other companies who will provide their support for software that they have developed.

And so in those cases, the customer would come and say, we’ve got X Y, Z piece of software, can you help maintain it or add a few features?

And the answer will be no, we didn’t build it.

So we can’t support it.

But on the other hand, we could rebuild it to a new version, and then support it after that.

So they get the double dip of writing a new piece of software and getting the support.

So I think there’s that missing, that missing offering where developers are available to support existing software that someone has invested in, it could be a good piece of software.

But sometimes, yeah, it just seems that other developers don’t want to sort of touch stuff that they didn’t develop.

I think there’s a real skill in being able to pick up someone else’s code with not a lot of supporting documentation or a lot of experience with that piece of software and be able to work with it in a quick time being able to unravel how things are put together, understand all the nuances.

Being able to deploy new versions, fix bugs, and set up a development environment, so all the developers can, can make effective changes.

So and I think that might be the underlying reason why a lot of people don’t like to offer that service is there’s no fixed procedure, it’s very much an ad hoc, problem-solving exercise, it can’t be streamlined.

You can’t write a manual for it and say you want to do this, this, this.

And because it is a piece of custom software, there’s no guarantee that they’ve followed the same guidelines as another piece of software.

And it can be a tricky exercise to undertake.

We’ve got a good team who has been able to do that time and time again.

So we’ve taken on a lot of new projects, where we haven’t developed the software we’ve been provided no documentation, some, some accounts, we just don’t have or didn’t have.

We weren’t familiar with the servers that the software was deployed on.

But just we were able to sort of inch our way through discover all discover a lot of the problems, make improvements, and document things so that we do the housekeeping and leave it in a better state than what was provided to us.

And I think the benefit to us in doing that as well as we build a relationship with the customer.

It shows that we do care about their software, we do care about their business, and we can help them out of a pickle because that’s ultimately what they want.

They’ve got a problem they just need someone to help them solve it.

And then moving forward we can usually have been entrusted with more feature development and potentially bigger project Next.

And I think that’s, that’s a bit of lead generation there in that we’re not always after, we don’t start with the big projects that we want the six or seven bigger some projects upfront, and then we’ll do the support.

But if we start with the support, which are the small, the small numbers, and hopefully that grows into the bigger numbers down the track.

One customer that we do currently have, he’s a good example of this software insurance support idea.

He very rarely makes contact, but what he does he’ll, he’ll reach out via an email or phone call and arrange a time slot just to sit with him for an hour or two, which could be on a team call.

He’ll screen share This is the problem he’s encountering this is what he’s tried to do.

This is what he’d like to do these what do we recommend he try or how does he fix that issue?

And so we’ll sit there together for an hour or two, provide some documentation, some links, maybe even fix the issue right there on the spot with him.

And he goes away happy, his problem is solved.

And we also have some other clients that do prefer face-to-face, so one of them is in Melbourne.

So we’ll either have a phone over there before going on site.

But other times, we just get the boys in Melbourne to do it.

And they go on-site and work on the server right there.

They just like to have we didn’t have remote access to that server.

They just like to have someone there and they can talk to them in person and discuss the issues.

That particular server, Windows Server, and other servers that we work on a Linux servers.

So it doesn’t matter, the platform we work on.

Doesn’t matter the technology.

So we still, try and concentrate on PHP and dotnet, and Python as the back-end type languages, front-end Angular, React and HTML, and CSS, those types of technologies.

We have looked at supporting other things like VB.

And while it is possible, when we start departing too broad from our core skills, then it comes becomes a little bit difficult because you have to have a lot of different development environments set up on every developer’s PC or laptop.

And then it just becomes a logistical issue.

So while we do support lots of different software, we do try and constrain it to some degree.

Just to prevent that context switch issue where developers are thinking about one, they’re working in one paradigm, and then all of a sudden, their lives have to separate into something completely different than just a time sink, we lose time, readjusting how you think about a problem because the technologies are just so different.

So we try and constrain it that way.

And for that reason, we don’t do a lot of desktop application support either, but focus more on that mobile web application type arrangement.

We also have help customers who use this support to just get general technical advice, just they might do their research on Google.

But just having someone that they can trust to talk about technical issues and get an unbiased opinion is valued in their business.

Things might be if they want to, if they’re looking at bringing a different piece of software that they purchased to purchase, like from us on a subscription or monthly subscription into their business.

How would that work?

How would it integrate with what systems they already use?

Those sorts of things could be if we get an in-house developer, what skills should we be putting in the ads?

What technologies do we need to advertise for?

And even to run the interviews and sit in with the interviews to make an effective hire?

Because a lot of these people that do own businesses aren’t technically minded, but they might be in the aged care industry, for example, and they’re experts in that area that they need technology to help run their business but they’re not technically minded.

So they just need someone they can trust and help them along the way in those areas, as they need it, but not full-time.

MORE FROM QUBISOFT

Process + Plan = Perfection

Start Reducing Your Operational Costs Today

Make an Enquiry

The Custom Business Software Show – Episode 1: The Custom Business Software Development Process