Outsourcing : The Benefits and Sacrifices

Outsourcing is the strategic approach to providing a capability to your organization by having it provided by another organization - one that specializes in that specific area. This approach applies to many different capabilities and services. This paper focuses on computer software and provides a summary of the benefits and sacrifices, which accrue to an organization by adopting this approach. Outsourcing software is not a good strategy for every organization. But where it fits, it is an exceptionally good business strategy. There are at least two ways to view the issue - one from the viewpoint of a software engineer, the other from the viewpoint of management of a company with information system requirements. We will look at both.

The benefits of outsourcing to the client include benefits enjoyed due to aspects of the software engineering company and due to the client not having programming and development staff in-house.

Benefits from properties of the outsource software engineering firm:

* Depth of Team - professional Design, Programming, Quality Assurance & Testing, Documentation, Training, Maintenance & Support,
* Collective experience of the team,
* Structured approach and its cost effectiveness,
* Efficiencies enjoyed through re-engineering previously written code,
* Knowledge of end product capabilities from the beginning,
* Knowledge of timeliness throughout by milestone definition,
* Tools available - Design, Development, Documentation, Training, Maintenance, Protection,
* Most cost effective use of costly talent,
* Definable costs for product enhancements,
* Implementation tools selected to fit the needs of the project, not programmer skills,
* Training and Help Desk services.

Benefits from avoiding in-house programming staff:

* Reduced payroll and fixed expenses,
* Freed Hostage - No dependence on employee continuity for software support and maintenance,
* Only scheduled, tested, and approved releases to the user community,
* Overall reduced costs, and no ongoing costs associated with use of the software,
* Ability to evaluate cost/benefit of any proposed enhancements,
* Decisions made in the best interests of the users and core business of the company - not curtailed by programmer issues or sensitivities,
* Reduced time of staff consumed in design, development, testing, training, and documentation,
* Reduced time required to deliver product.

A more detailed discussion of each of these follows.

Depth of Team. Outsourcing will give the company a depth of team members that are rarely provided by a typical in-house staff. To build sound, versatile, and comprehensive software, design databases which accommodate near and long term needs, you need capable, experienced, and focused talent. High quality information systems are not just written. Each step in a series must be completed correctly in order to provide a high quality, relevant, and durable IS (information system). This is accomplished by an IS team. Management and operations staff must be queried to obtain the full set of requirements, priorities, constraints, views of the future, and inputs relevant to the design of the IS. A design team compiles these into a Design Definition document and iterate with management and operations staff in defining the target IS (or the blue print of the IS) to be constructed. The software development team builds the IS to the specification. Every hour spent in the design definition will save many hours in the software development effort. Additionally, it will save hundreds of hours in time required to support the IS later on. Not only will a well designed IS require less code to implement, it will be more modular, it will have common functionality achieved by the same code bodies, and it will be buildable in fewer iterations than will a poorly defined and designed IS. As the software development team is building modules to the IS, the Quality Assurance team is confirming that the software adheres to the specifications set forth in the design, and the Documentation team is translating the design specification and the operations of the software into user documentation and systems documentation. Rarely can these different roles be filled effectively by one person each. Each of these is a very important element of constructing a successful IS. Neglecting any of these elements will result in limitations of the target system. Outsourcing should give you access to personnel of much greater technical depth, experience and training than you would have on your internal staff. Many outsourcing companies will have senior software, database, communications, or network engineers with advanced degrees (Ph.D. or M.S. in Computer Science or Electrical Engineering, Certified Network Engineer, or other certifications). While they are not generally fully assigned to a single IS development project, the team members do have access to this talent and intelligence when needed to address particular IS issues.

Collective Experience of the Team. There is nothing that compares with collective experience or collective intelligence. If our knowledge base could only benefit from the experience of a couple dozen of our professional peers, we would be vastly more effective. Outsourcing enables you to tap into the knowledge and experience of professionals who have addressed IS problems very similar to your own. The value of this knowledge and experience would be difficult to overstate. They are the basis for: quickly arriving at workable designs, providing accurate estimates of time to deliver and various personnel time required, tool selection based on the nature of the project, which existing code has a good fit and dramatic efficiencies gained from re-engineering existing code, ..., etc. This industry is replete with examples where qualified personnel have spent weeks or even months grappling with a problem, only to have the solution identified in hours or minutes by someone brought in who had more experience in that particular problem domain. The axiom, "Knowledge is Power" applies to this field like no other. If it could be stated more accurately, it would be "Knowledge is Time and Money Saved". The value and cost reduction affect of the collective knowledge and experience alone, could justify outsourcing a development project.

Structured approach. No one would think of building a house by hiring a carpenter, have them go to the site, discuss what is wanted for a house with the future resident, and then just start building the house! The amount of in-house software that is constructed in this fashion is mind-boggling. Members of the design team must spend the needed time with the pertinent members of the client organization in order to accurately and completely identify the needs of the organization and their priorities. It is here, with the design team members of the software engineering firm that the personnel resources of the organization should be focused. The quality of the job performed in the design phase will define the potential quality of the end product. No subsequent phase of the development cycle can make up for or recover from deficiencies introduced in the design phase. The importance of this phase is highlighted because this phase conventionally is neglected or hastened by in-house programmers. "Heads down programmers" are an essential element of the development team. They are necessary, but alone not sufficient, for a successful development project. Outsourcing gives the client's project the benefit of all members of the development team who greatly enhances the quality of the product.

The structured approach includes: accurate and complete definition of the problem or task; complete and consistent system design (complete definition of the data structures, user interface, work flow, performance requirements, multi-user considerations, security, error sensitivity, recovery, support utilities, inputs/outputs); well engineered implementation (database definition, communications engineering, software requirements definition, library selections, identified re-engineered components, and code development); quality assurance and testing (verification of the design as well as operational modules); documentation (user and systems); training procedures (where needed); end user technical support or "help desk" provisions.

Efficiencies enjoyed through re-engineering previously written code. This has become a very hot topic now that the development community has accumulated a considerable body of software, which has been written with the object oriented design paradigm (or has been written in a highly structured and modular fashion). Any software engineered for ease of maintenance and modular functionality is a high candidate for use in re-engineering. For example, a subroutine used to determine the weekday of the first day of a month and year, could readily be re-engineered to determine the weekday of any day-month-year combination. The increased size of the pool of existing software and the experience in re-engineering existing code can make outsourcing extremely cost effective. The time required to re-engineer an existing code body may take 5 to 10% of the time required to write the same code body from scratch. The result is huge savings to the client. Additionally, re-engineered code is much cheaper to support, refine, and enhance than is new code.

Knowledge of end product capabilities from the beginning. Working with an experienced design team provides the client with a very good understanding of the expected capabilities of the end product very early in the development cycle. It is very frustrating to wait until the software has been built to learn that certain features are not feasible given the time or cost constraints, limitations of the implementation tools, or some other factor. An experienced design team will lead the client company through the tradeoffs, considerations, and costs of each of the target features. If there are features, which are not feasible in the context of other operational constraints, the client company can know this before any implementation effort is begun.

Knowledge of timeliness throughout by milestone definition. The structured approach identified earlier also provides a series of measurable accomplishments during the course of developing the product. The completion phases are the "mega milestones". Each phase has well defined subsections. Some are sequential; others can be pursued concurrent. The client company can see clearly where the project is “on the map” to completion at any given point in time. In response to your inquiry as to when the product will be available for use, you really don't need to accept that programmer quip, "not yet" or "soon, very soon". The structured approach provides a schedule for each of the various phases enroute to the end product.

Tools available. The tools available to the effort of software development are ever increasing in number and power. The days of designing on paper, writing all the source code, compiling each module, manually linking and debugging are part of history. Today we have tools, which assist in automating each phase of the project including Design, Development, Documentation, Verification, Testing, Training, Security, Maintenance, Protection, and Help Desk. The software implementation and verification processes have been greatly enhanced by tools directed at streamlining their work. Comprehensive and well tested libraries of routines are now available for just about any topic in development ranging from sound, imaging, communications, database, data entry, graphical user interface, on-line and context sensitive help, bar code, and others. Many of these products are accompanied by suites of development tools, support utilities, migration utilities, drivers and testing tools. Tools to assist in automated source code generation exits for many of the development areas. Additionally, many tools exit today for code verification, debugging, execution monitoring, and testing. All of these can be used by the software engineering firm in providing the development service without additional cost - they incur no royalty fee for each installation. So the client company can benefit from the investments in software development tools made by the software engineering firm - the costs are amortized over many contracts. While software engineering firms tend to wield 4GLs (Fourth Generation Languages) more effectively than in-house programmers, these usually carry a royalty fee and in many cases do not offer the performance required. These development tools have come a long way in performance, but many still fall short of requirements for many projects. Companies which have software development as their core business have the armory of tools to perform this service in the most efficient fashion possible. Using these companies enables your products to benefit from the use of these tools.

Most cost effective use of costly talent. The development team may be required to consult with the most senior engineers on various isolated matters. The development effort benefits from the unique experience and depth of various resident specialists, but the client firm incurs only a small fraction of the costs of maintaining these individuals on the staff. The benefit is huge, the cost is very little. This benefit alone, in certain types of projects, will make outsourcing the definitively superior option.

Definable costs for product enhancements. This is really just a side-effect of number 2 above (Experience of the team). It is worth noting, as it is a source of ongoing frustration for many companies with in-house programming staff, to get realistic estimates of employee time required to provide a desired enhancement. The experience of the software engineering firm provides this ability. Additionally, being a contract organization for the client company, the client has substantial leverage in the form of performance agreements, to get the job done per design, on time, and within budget.

Implementation tools selected to fit the needs of the project, not programmer skills. This is much less a concern than the others, but in the effort approaching a comprehensive coverage of this topic, it has to be recognized. We hear about it more frequently than one would expect. A product is being developed with a particular project because it is familiar to the developers, not because it is particularly well suited to the problem or project.

Training and Help Desk services. Training is an essential ingredient of a successful implementation. It is often spurned by programmers (especially "heads down" programmers). Having the outsource firm provide the on-site training and ongoing Help Desk service will ensure a successful and full use of the product. If the product is going to be used by many users, the user community has a fairly high turnover rate, or the product has many features some of which are needed infrequently, then an effective "Help Desk" service may be needed as well.

These are the salient benefits to outsourcing your IS needs to a software or IS engineering firm with many projects to their credit. How to select the best outsourcing firm is really a topic in itself and is beyond the scope of this paper. There are other benefits to outsourcing, but they generally are not so important as to provide a notable basis for outsourcing as opposed to in-house development.


Reduced payroll and fixed expenses. Naturally enough, if you outsource your software development you won't need any in-house programmers. This is staff that draws pay all year, every year. Outsourcing removes this expense. When the required products have been completed what are these people doing? If you increase and reduce programmer staff based on product requirement cycles, what quality of people are you inclined to retain? The payroll is one of the ongoing costs. The FICA, health benefits, disability insurance, 401K, office space, furniture, computers, phones, development tools, and all the supplies and other expenses are incurred with the in-house approach. A full year of a $50,000 per year programmer quickly becomes a 65 to 70K per year cost.

Freed Hostage - No dependence on employee continuity for software support and maintenance. Many organizations with in-house programmers feel that if they loose the programmer, the use of the product will greatly diminish. They get this feeling, most frequently, from the constant attention the programmer gives to the product. This should be sounding alarms and you should run (not walk) toward an exit, not further into the building! The outsource company should deliver a fully verified, tested, and well documented program. It will usually need some minor modifications after delivery, but should be the target product and well behaved within several weeks on the outside. The length of this post delivery modification period increases with decreasing quality of the job performed in the design phase. If the design phase was never completed correctly, this post delivery modification syndrome can go on for a very long time.

Only scheduled, tested, and approved releases to the user community. It is not uncommon for the software developed in-house to be released into the user community without a schedule and without full testing and verification. Releasing software in this fashion tends to be very disruptive to the user community. A fix for one problem may create another, or alter a feature, or the behavior of certain modules. For well designed and highly modular software there may not be any side-effects to changes in isolated areas of the software. But these two features often give way to the "quickly encoded" feature of in-house development efforts. It is not to say that there are not some extremely qualified and capable in-house software development teams to be found in companies. They are simply out populated by their less celebrated species.

Overall reduced costs, and no ongoing costs associated with the use of the software. The cost for providing a specific capability through outsourcing is definite and discrete, compared to the cost of in-house being continuous and indefinite. Even if the outsourcing company is contracted to provide Help Desk service and some required modifications, this will be much less expensive than maintaining in-house programmer staff throughout the use of the product.

Ability to evaluate cost/benefit of any proposed enhancements. When using an outsource firm, you will receive (or should require) a cost estimate for the proposed enhancement. Highly complex enhancements may require a fee to perform the work in developing the estimate, but an estimate can and should be obtained. You can weigh the cost against the added benefit of the feature, and pursue the feature accordingly.

Decisions focused on core business of the company and users, period. Outsourcing allows you to focus fully and without compromise on the core business and the needs of the users servicing that business. In-house programming efforts must often be accommodated by compromising some set of needs in the user group in the form of features, performance, user-friendliness, or time to deliver. If the outsource firm is not fulfilling those needs, you replace them. The source code, documentation, and associated files and records are transferred much like patient files.

Reduced time of staff consumed in development effort. It may seem like the software engineering firm is consuming a lot of staff time with their problem definition and system design meetings, then reviewing and confirming tedious design definition documents. After the completion of this phase, very little time is required of the client firm. However, in-house staff tends to pull on personnel time in an ad hoc fashion. They often work under the same roof, or just down the hall. If they have a question or problem they'll just pop into to the appropriate persons' office and resolve the issues as they arise. While this sounds easy enough, it adds up to a very large consumption of time and impacts other activities and responsibilities of the personnel involved. It also reduces dramatically the structured and systematically defined design. Ad hoc techniques result in ad hoc design - which rarely arrives at a stable design definition. The demands on staff time of in-house programming efforts tends to be ongoing - indefinite and continuous, just like the project.

Reduced time required to deliver product. In most cases, outsourcing will result in the product being provided in less time than that of in-house efforts. There are several factors which enable the outsource company to be more timely. The first being the breadth of the team - "many hands make little work". The other factors will depend on the nature of the product and the history of the outsource firm. If they have performed similar projects in the past, then direct experience, re-engineering existing code bodies, using object libraries, and other tools will play a major role in reduced time to deliver. This is not always the case however. A project cannot advance if the time and effort is not allocated to it. Some outsource companies tend to bite off more than they can chew. Naturally, this will not assist in a rapid delivery. In-house efforts can be made to drop all else and focus exclusively on a particular project - or jobs will roll. A similar dynamic can be applied to outsource firms through the use of target date incentives and penalties.


Outsourcing is an excellent fit if your organization is characterized by :

1) Main focus of business is providing goods and/or services and the procedures and policies are fairly well defined,

2) Management and personnel have a comprehensive and accurate understanding of their business dynamics,

3) A good understanding or view is held of what capability is required of their IS (Information System) in order to resolve or address their needs,

4) The fundamental requirements of their information system are not highly dynamic - while specific requirements may arise weekly or monthly, the fundamental or central requirements do not change very often (annually or biannually, at most).

5) The details of the operation to be embedded in their information system are not so highly sensitive as to be protected by a solid nondisclosure agreement.

Most companies which maintain an in-house programming staff, do so because of very good reasons. They should take a hard look at their reasoning to ensure that they are not sacrificing the benefits of outsourcing for the luxury of suffering through the costs and demands of providing these services in-house. Below are the most common reasons management decides on providing in-house staff to accommodate the company's IS needs. These may or may not be true. Careful consideration of the company's actual situation is required to come out ahead with whatever strategy they employ.

1) The company IS requirements are very dynamic, and outsourced services would be too slow in providing their needed capabilities. Many organizations who see their IS needs as being too dynamic to be compatible with the outsourcing strategy, actually have a fairly static set of IS needs, but a highly variable understanding of those needs. Additionally, the rate at which the priorities among their various IS requirements change, should not be confused with the actual set of fundamental requirements of their IS. If a company can list and agree on the high level, information oriented requirements of their IS at any given point in time, and if each subsequent list contains additions of lesser or equal importance to the organization than the entries on each previous list, and they are small in number relative to the preceding lists, then their needs are much less dynamic than those which warrant an in-house staff.

2) They need a high degree of control over the IS in order to assure that it meets their needs,

3) Their IS needs are sufficiently unique to require an in-house staff,

4) They can provide for their IS needs more effectively than could a third party.

Outsourcing is a great means of meeting your software capability needs. It may or may not be the best means of serving those needs. Hopefully, this article will assist you in weighing the various factors which will determine which approach to employ.



OffShoring Engineering