Systems‐Development Life Cycle

The development methodology, systems‐development life cycle (SDLC),

was first developed in the 1960s to manage the large software projects

associated with corporate systems running on mainframes. It is a very

structured and risk‐averse methodology designed to manage large

projects that included multiple programmers and systems that would have

a large impact on the organization.

Various definitions of the SDLC methodology exist, but most contain the

following phases.

1. Preliminary Analysis. In this phase, a review is done of the request. Is

creating a solution possible? What alternatives exist? What is

currently being done about it? Is this project a good fit for our

organization? A key part of this step is a feasibility analysis, which

includes an analysis of the technical feasibility (Is it possible to create

this?), the economic feasibility (Can we afford to do this?), and the

legal feasibility (Are we allowed to do this?). This step is important in

determining if the project should even get started.

2. System Analysis. In this phase, one or more system analysts work

with different stakeholder groups to determine the specific

requirements for the new system. No programming is done in this

step. Instead, procedures are documented, key players are

interviewed, and data requirements are developed in order to get an

overall picture of exactly what the system is supposed to do. The

result of this phase is a system‐requirements document.

3. System Design. In this phase, a designer takes the system‐

requirements document created in the previous phase and develops

the specific technical details required for the system. It is in this

phase that the business requirements are translated into specific

technical requirements. The design for the user interface, database,

data inputs and outputs, and reporting are developed here. The

result of this phase is a system‐design document. This document will

have everything a programmer will need to actually create the

system.

4. Programming. The code finally gets written in the programming

phase. Using the system‐design document as a guide, a programmer

(or team of programmers) develop the program. The result of this

phase is an initial working program that meets the requirements laid

out in the system‐analysis phase and the design developed in the

system‐design phase.

5. Testing. In the testing phase, the software program developed in the

previous phase is put through a series of structured tests. The first is

a unit test, which tests individual parts of the code for errors or bugs.

Next is a system test, where the different components of the system

are tested to ensure that they work together properly. Finally, the

user‐acceptance test allows those that will be using the software to

test the system to ensure that it meets their standards. Any bugs,

errors, or problems found during testing are addressed and then

tested again.

6. Implementation. Once the new system is developed and tested, it

has to be implemented in the organization. This phase includes

training the users, providing documentation, and conversion from

any previous system to the new system. Implementation can take

many forms, depending on the type of system, the number and type

of users, and how urgent it is that the system become operational.

These different forms of implementation are covered later in this

reading.

7. Maintenance. This final phase takes place once the implementation

phase is complete. In this phase, the system has a structured support

process in place: reported bugs are fixed and requests for new

features are evaluated and implemented; system updates and

backups are performed on a regular basis.