"The software is too slow and not scalable. It would be better to program the whole thing from scratch. That gives us a better starting point."

Do you also know such statements? Unfortunately, they are very common, because there are many developers who prefer to write new code rather than refactoring existing code. The reasons for this are diverse. But often it is because developers think the old code is a mess and reading it requires a lot of effort.

In my opinion, however, this is not the best solution.

Advantages of the existing software

The idea that the new code is better than the old one is absurd in most cases. The "old" version has already been used by customers and tested again by developers. Many bugs that have already appeared during the runtime of the application could probably already be fixed with a lot of effort.

For example, if I were to throw away the existing code and start from scratch, I would throw away all the brainwork behind the software. All the collected solutions to all kinds of problems would be thrown away.

An example

Netscape Navigator - first released in 1994 - was the most popular Internet browser for years. Only in 1998 the Microsoft Internet Explorer appeared. As a result, Netscape decided to rewrite their entire software from scratch to follow the competition. The development team then focused mainly on the new code and neglected the old one.

Microsoft's browser became more and more popular and Netscape was unable to maintain its market share. The defeat is probably not only due to the new conception. But the rewriting of the software certainly contributed to it. The end result was the demise of a company that was once very successful. See this blog entry for an example.

The better approach

The better solution in most cases is to continue working on the existing code. If you find that some parts of your code are inefficient or unreadable, I advise you to improve those parts step by step - instead of discarding them completely. Over the years, the development team probably no longer consists of the people who worked on the first release. After all, the current team probably does not really have "more experience". As a result, there is a risk that old bugs would be repeated or new problems would arise that were not present in the original release.

However, if you notice that there are big differences between the current version and the best version of your product, I would recommend to build a new software, but without throwing away the previous one! This way the previous learnings are preserved.


Although Renuo is derived from "to renew", we judge each project individually and decide to rewrite or enhance existing code as appropriate. In cases like Uber, for example, it makes sense to redesign an application. However, my advice is that you always evaluate a new concept carefully first, not forgetting that some companies have already failed at this step.