Google Analytics

Why is rushing never a good idea in software development?

Why is rushing never a good idea in software development?

3 min read
Nov. 25, 2021
Krzysztof Waliński
×
Krzysztof Waliński
Business Development
3 min read
Nov. 25, 2021

Being the first line of contact in a software house is a fascinating, yet challenging task. Every day I listen to passionate people who have brilliant ideas. And very often, I ask them to take a step back, take it slower, and even make them question their own way of thinking.

Of course, there’s generally nothing wrong with acting quickly, as long as we’re not being neglectful. But there’s an old Polish saying: “haste is a bad advisor”. And just like there’s a reason for speed limits in every country, there’s a very good reason for research and preparation before software projects start.

Because when it comes to software development, we should never take any shortcuts.

Four reasons why we think we need those tempting ASAPs

Certain business circumstances make us feel like there’s absolutely no time to waste. Walls are closing in, and there’s no escape unless we start our project immediately. We get it. However, most of those reasons are highly misleading. Instead of rushing, they often require us to take a step back.

1. Our investors are waiting for quick results

On a surface level, this seems like a good reason to be in a hurry. However, the risks that come with rushing things actually put your investors’ money in danger. Be patient and ask for patience. Let them know that success in software development must be built on a solid foundation of research and planning. Without it, we’re not able to identify risks, opportunities, etc. Therefore, we can’t build software that truly corresponds with business goals, which ultimately puts the whole project at risk.
Then, of course, feel free to send them this article.

2. We operate in a highly competitive market, and we’re already behind

In this case, you need to ask yourself what’s your competitive edge. Is it enough to get your share of the market? How similar is your solution compared to those that already exist? Remember never to underestimate the first-mover advantage.
In some cases, it may turn out that the competition is clearly too far ahead and there are too many risks, so starting a project simply isn’t a good idea. Either way, again, proper research is mandatory.

3. We want to find out what’s the interest for our product before we burn too much budget

This is one of the common scenarios when founders want to quickly build an MVP (Minimum Viable Product) version and go from there. Although this line of reasoning makes much sense, we shouldn’t make it a primary motivation behind our actions. It sometimes works out, but there are other, cheaper ways to find out if there’s a market for your product.

  • Professional market research
  • Crowdfunding
  • Building MVA (Minimum Viable Audience)

4. We’re can’t wait to see our idea come true, simple as that

It’s completely natural to be impatient about a fascinating idea. But the rush that comes with excitement may result in ill-advised decisions and incomplete plans. That’s why starting a project too early may delay the development process significantly. It’s always better for a project (and budget) to use that energy to complete each phase of the planning process diligently.

In most cases, it’s impossible to rush the process

The most simple rule is that processes take time for a reason. There are necessary steps we need to take before we start writing the code. Some of them are fundamental; others are highly recommended. Skipping any of them only increases risk. What are we talking about particularly?

Research

Despite similarities between projects, even in the same industry or technology, each one has to be treated individually. A software house needs to understand the client’s idea, business needs, and challenges. In order to do so, we study all materials that the client provides, whether it’s a list of features, whitepaper, or presentation. During this phase, we have to rely on the client to discuss the product with us in detail. The more comprehensive answers we get, the faster the research process will be.

After we have enough information, we need to answer the following questions.

  • What technology will be ideal for the project?
  • What features will be required at what phase?
  • What are the risks?
  • Do we need MVP, or can we immediately start something bigger?

In addition to the information given by the client, it’s also necessary to take a closer look at the competition, their methods, strengths, weaknesses, and opportunities. During the research, we analyze the potential of the project and possible risks. It’s entirely possible that during the analysis, we’ll discover too many risks and, in the current state, we simply do not recommend starting the project. Maybe the idea just needs to be thought over a bit more. In the end, the client’s success is our main priority. We want to build partnerships for years, so we make sure only to create software that can be successful and stands the test of time.

Preparing the offer

After the research is completed, we’re able to prepare:

  • Scope of work
  • Cost and time estimate

The process can take a few days. After we present it to the client, there’s a time for discussion, negotiation, and often slight modifications to the project.

Contract, NDA, documentation

Whether we like it or not, paperwork is an essential element of every software development project for the necessary security of both the agency and the client. That’s another few days or more, depending on the level of security required and often the speed of corporate procedures. Only after the offer is accepted and we’ve finished with all the paperwork, we can proceed to assemble the team.

Assembling the team

Software houses rarely have teams of developers (and PMs or scrum masters) just sitting around and waiting for a new project. Especially in good software houses. So in order to gather a complete team with all the skills we need, we have to either:

  • transfer them from another assignment (they time to need to pass their knowledge to someone else)
  • hire new people (we need time to find the right people)

It’s perhaps the most time-consuming process, but a well-suited team plays a fundamental role in the development. So taking shortcuts here is a huge no-no.

Why shouldn’t we rush with any of those processes?

Some of the processes like completing paperwork simply must take some time. For others, such as research, rushing is usually not worth the time saved. There are too many risks, such as:

  • We estimate the budget or time incorrectly
  • We choose the wrong features to implement at this stage (or at all), which take a considerable chunk of the budget
  • We assemble an insufficient team for the project
  • Consequently, we release buggy or incomplete product

In some cases, however, there might be a valid reason to skip some important steps for the greater good. Of course, it usually comes with certain risks, which we always identify and explain to the client. Communication must always play a major role in such situations because the final decision should always be made knowing potential consequences.

What can we make faster?

One of the processes that can be accelerated is development. First, it’s possible to assign additional developers to the project. Second, we can limit the number of features that we implement during the project’s initial phase. But, as you see, those methods actually don’t mean that developers will work faster or twice as hard. They won’t type more quickly for double pay, there’s just more of them. This type of “rushing things” in software development is usually deadly. Moreover, many features in software can’t be developed simultaneously. Developers need to wait for previous elements to be completed before we start further ones.

There’s also an aspect of industry experience and technology expertise. As a team with many bioinformatics and blockchain projects, we know the domain, and we can understand such software projects much faster than most software houses. That, however, also doesn’t mean we’re rushing any processes. We’re just able to can skip some parts of the basic research.

Additionally, we’re experienced in MVP development. Building MVP versions efficiently requires an established set of processes, so having some of those projects in the portfolio is a huge help. You can read more about the subject in the article by our CEO, Adrian: 7 golden rules for MVP development.

Patience and diligence pays off

Several months ago, a client approached us with an interesting project, but there were some risks that we wanted to eliminate before we committed. So we came up with an idea to prepare a proof of concept (PoC). A client agreed to the proposition and after a couple of months, we’ve presented it and confirmed that the idea was feasible. Thanks to that process, the client was assured that there was real potential in the project. After a few conversations with investors, we got a green light for the project.

Of course, making PoC is usually a strategy reserved for situations when standard methods are insufficient. More often, we just need to do the necessary research. But the point is that the phase cannot be overlooked.

  • Certain processes must take time for the good of the business
  • Rushing or skipping any phases will increase risk significantly

There’s a huge difference between taking shortcuts and finding ways to deliver something quicker. We are always flexible and we have our ways to work within tight schedules, but we always prioritize the client’s success. So far, we can say that this mindset worked out pretty well for us and for our clients.

So if you’re looking for a team that focuses on your business goals first, arrange a call with me and talk to me about your project.