Building custom software: A strong process is key

A strong software creation process should contain clear, identifiable stepping stones.

My team has seen (and fixed) a lot of badly conceived and badly coded software over the last decade. If I had to name the number one cause of bad software, it’s this: a lack of proper planning. It’s not a lack of budget; it’s not a lack of talent; it’s not a lack of resources. It’s the lack of a formal process with clearly laid out and well-understood steps along the way.

In this article, I’m going to give you an overview of a process that has worked well for my own software development company, igNew. My team and I have been designing and building custom software since 2005 and I’ve learned a lot along the way about what works and what doesn’t work.

And by me writing about the process at my company, I don’t intend to imply that that our way is the only way to do things. But I do believe that the key points of our process must be present in some form or another for any successful software project.

Causes of bad software

You would think that it would be pretty obvious to most people that good software takes strong planning, so it’s first helpful to understand how a lack of proper planning comes about.

Most of the time, when a company decides they need custom software, they haven’t built software from the ground up or overseen the software creation process themselves. In other words, it’s their first time. So they naturally look for companies to help them.

Some of these companies can be eager to submit a bid without knowing very much about what the true project goals are. Instead, they may rush to give an estimate, hoping the customer will like what they see and be ready to move forward. This is common in most businesses; companies make a low-ish bid, hoping to get a contract, without fully knowing the scope.

But what works in most areas doesn’t work in software. You may get a working software by going with such a normal bidding process, but it won’t be strong software. It won’t be optimal, built-to-last software.

My team takes a different approach. To start with, we don’t give a formal estimate on the complete software project until the third step in our process. So without further adieu, let’s get to the process:

Step 1: Initial consultation

The initial consultation is when we get to know your company and your company’s software goals at a high level. We try to ascertain basic things like:

  • What are the big-picture goals you are trying to accomplish with the software?
  • What challenges or opportunities led you to choose to build custom software?

The initial consultation can be one or maybe two meetings. We get a sense of whether our two companies would be a good fit and start to lay the groundwork for:

Step 2: Discovery

Discovery is arguably the most important part of the process. Discovery is when we start to dig deeply into the ‘why’ and ‘how’ of your software. It’s where we translate the high-level goals of your software vision into a tangible, practical plan.

Discovery is typically around 3-4 weeks long. This may seem long, but trust me: patience here is hugely important to building great software. Because planning isn’t as “sexy” as building, this is when an urge to skip steps can appear if you’re not careful.

  • What specific problems are we trying to solve? (Because software is always about solving specific, tangible problems.)
  • Who are the users we are solving these problems for? (It might be your customers, it might be your employees, it might be both.)
  • What are some characteristics of those users? (i.e. they are a younger tech savvy bunch, they are older and use software seldomly, they like to do their work on tablets and mobile phones, etc.)
  • What specific functions and abilities will those users need to be able to do with the software?
  • Of all the things the software could do, what is the minimal amount of functionality that can be built to deliver the maximum possible value.

It’s kind of like making a movie; you don’t just get an idea for a movie and start shooting. You first take a lot of time crafting and polishing and rewriting a script. Because when you actually get to shooting that movie (writing the code), you want the strongest script in place you can possibly have. Changes do happen, but those changes are generally a lot smaller and less impactful when you’ve spent the time up front thinking things through.

During Discovery, we talk to the software’s end-users to get clear about what they need. We meet with them one-on-one or, if that’s not possible, we talk to them online or even send out surveys. This is hugely important to the process.

During Discovery, we discuss what the minimal viable product (MVP) might be. In other words, what’s the simplest effective software we could create that would bring the most value to the end users? What would that take to build? What software functions are essential to an MVP? What functions are secondary? What functions are perhaps really just bonuses and "nice-to-haves"?

At the end of Discovery, before moving on to the next stage, we provide you with documentation of our findings and conclusions and a detailed description of what we think the ideal solution looks like for you. At this stage, we also provide you with a detailed pricing estimate for the actual build.

If you like what you’ve seen from us, you can use us to build the software. But if you decide not to, you can always take what’s now a much more flushed-out, tangible blueprint and go to other software teams.

Step 3: Implementation

Implementation is when the interface design and coding take place.

The most important aspect of this stage is communication. As we build the software from the blueprint we created during Discovery, we stay in regular contact with you to show you how things are progressing, and to get your feedback. We meet with your team (virtually or in-person) at a minimum of once per week. You are fully aware and involved with what’s being built every step of the way.

One of the first steps is interface design. We mock up screens and interfaces, so that you can see how the software will work. We give you demonstrations and walk-throughs of how users will access and use these screens.

As we build the software, we provide you with a test environment where you and your shareholders can use the software as it evolves. And again, we collect all feedback and make sure we’re still on the right track.

Once everything is complete, the igNew team and the client’s team will conduct final testing, and get ready for launch. The great part about strong communication during this phase is that end-testing is minimized. If we have done our job and kept you in the loop, then there are no sudden, expensive surprises or setbacks at a project’s end.

Finally, igNew guides you in the release of your software to your end users. If applicable, we’ll help you with hardware and hosting requirements and help you understand what’s involved with maintaining your software after it’s launched.

Step 4: Post-launch support

After your software is out there in the world, it can be tempting to call it a day. But this can be a time for dramatic improvement of your software.

This is a time to get the software out to an active group of users and collect feedback and ideas for improvements. No matter how well you plan, there is no testing that is as thorough as the testing that takes place in the real world.

Once you gather enough feedback, we can come up with a plan for making any desired improvements to the software. Sometimes there will be changes that it’s smart to make sooner rather than later. At other times, it can be beneficial to leave things alone for a while to see how the software performs longer-term.


It can’t be overstated how important a strong process is to building great software. No matter who you choose to build your software, think about the various stages I’ve talked about in this article and do your best to make sure those elements are a part of your process (especially Discovery).

I know that our dedication to a formal process is one reason we have so many satisfied custom software clients.

About igNew

I’m David Galownia, the owner and President of igNew. igNew is a proven software development team; we’ve been building transformative solutions since 2005.

At igNew, we’re driven by a passion for solving problems and enabling your business to achieve greater heights through technology. Our clients are typically medium sized, high-growth companies who are striving to be more efficient, more agile, and more profitable. We will work with you only if we’re confident we can drive a substantial return on your investment.

Schedule a Free Consultation to Discuss Your Project