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 capital Applications Source Code
Type Long-term asset Tactical asset Liability
Drives cache flow -- YES --
Operating expenses -- Fixed per time Grow over time
Lifetime 5 – 10 years 2 – 4 years 3 – 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:

Activities New System Existing Ad-Hoc Existing Optimized (1)
Understand existing architecture and design -- 80 24
Validate gaps between deployed systems and design documentation -- 24 --
Document new architecture and design 40 24 16
Documenting detailed design for new features 40 40 40
Understanding existing code -- 80 40
Coding new features 80 80 64
Component testing and debugging 32 40 40
Integration with new code -- 40 16
Code review (and updating documentation) 24 40 16
Understanding existing configuration and deployment -- 40 16
Documenting application configuration 8 16 4
Integration testing and debugging 16 80 32
Testing new features in QA 40 40 40
Regression testing in QA -- 120 40
Fixing bugs found in QA 40 120 40
Performance testing 40 16 16
Fixing bugs found in Performance 40 180 24
TOTAL (men/hours): 120 1,060 444

Table 2: Platform development cost structure

(1) The 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:

Figure 1: Software development cost – runaway operating expenses
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
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.