Any software development company operates three major components: an intellectual capital, software, and source code. The intellectual capital is a strategic asset that company builds over time. This includes people, patent, white papers, etc. Intellectual capital requires investment but not much of maintenance.

Software is the collection of applications and systems that company hosts or distributes. It provides business value to clients and drives cache flow. Running software is an asset, but it entails operating expenses like license fees, hardware amortization, data center maintenance, monitoring, backup, production support etc.

The source code, however, is not an asset. It is a liability that drives most of company’s operating expenses. These expenses include documenting, education, knowledge transfer, debugging, refactoring, integration, testing, etc. Unlike software, source code expenses have tendency to grow over time as the code became more complex, cluttered and patched.

Intellectual capitalApplicationsSource Code
TypeLong-term assetTactical assetLiability
Drives cache flow--YES--
Operating expenses--Fixed per timeGrow over time
Lifetime5 – 10 years2 – 4 years3 – 18 months

Table 1: Three components of software development organization

When you develop a new program it is a clean start. You do not have baggage to carry. You do not have to spend time to get familiar with existing code, regression testing and merging design for new features with existing design.

Modifying application software requires more effort. With each release source code became more complex and interdependent. It is getting worse as different developers leave and enter the process. This is why software development processes and methodologies are so important. Their goal is not only to make sure that all requirements are satisfied, but also to make software maintainable – easier to modify it later.

The following table illustrates end-to-end cost of an abstract system release from design through development:

Existing system
ActivitiesNew systemAd-hocOptimized1
Understand existing architecture and design--8024
Validate gaps between deployed systems and design documentation--24--
Document new architecture and design402416
Documenting detailed design for new features404040
Understanding existing code8040
Coding new features808064
Component testing and debugging324040
Integration with new code--4016
Code review (and updating documentation)244016
Understanding existing configuration and deployment--4016
Documenting application configuration8164
Integration testing and debugging168032
Testing new features in QA404040
Regression testing in QA--12040
Fixing bugs found in QA4012040
Performance testing401616
Fixing bugs found in Performance4018024
TOTAL (men/hours): 1201,060 444

Table 2: Platform development cost structure

1The optimized development assumes both development processes and system design are optimized for cost control.

The numbers above are provided for illustration purposes only. The cost of real project may vary, however you cannot avoid expenses associated with maintenance and support of legacy source code.

A new system does not have legacy source code to maintain. This is why a pilot or the first release of a new application is usually cheaper than subsequent releases. As the source code piles up, became more complex, cluttered and patched, the team has to spend more and more time to maintain it. Sooner or later it reaches the point when the team forced to abandon the old code and to start new development from scratch:

Development cost

Figure 1: Software development cost – runaway operating expenses

This problem must be addressed by optimizing both the development processes and application design. A software development organization has to follow proven systems engineering practice and to optimize development life-cycle. This allows reducing time spent or repetitive and unnecessary activities; resources reusing and simplifies knowledge transfer.

However, the process optimization will only take you this far. In order to keep the development cost under control the system architecture and application design must follow certain standards:

  • Encapsulation – design application as a composition of reusable modules (components) with stable interfaces that can be designed and tested independently from each other.
  • Business Rules – implement system parameters and business rules either as configuration files or a database. Reuse and share algorithms and patterns across multiple clients and requirements.
  • Process Automation – automate both run-time (transactions and workflow) and back-end processes (ETL, backup, build, deployment, etc.). Automate testing when possible.
  • Error handling – each component must implement independent parameters validation. Do not use exception to communicate planned scenarios, implement automatic error monitoring and notification.

An ideal result of combination of processes and design optimization will allow to “box” operating expenses and to significantly prolong software life time. This chart illustrates how an ideal state:


Figure 2: Software development cost – optimized design and processes

As you can see from this illustration, as long as code maintenance cost does not grow over time, the team will have time left for recursive improvements and development for new features.