Diary of an IT Guy #AnakBinus

Build Bridges, not Walls. Collaboration Forever!

Phases of the Software Development Life Cycle (SDLC)

leave a comment »

The software development life cycle (SDLC) is the process of developing software, starting from an idea and ending with delivery. This process consists of six phases. Each phase takes input from the results of the previous phase. There is no standard SDLC, so the exact phases can vary, but the most common are:

Phase 1. Requirements & Analysis

Phase 2. Design

Phase 3. Implementation

Phase 4. Testing

Phase 5. Deployment

Phase 6. Maintenance

Historically, development teams usually followed these phases in order in the waterfall method. The goal of waterfall was to complete each phase of SDLC down to the last detail before proceeding to the next, never returning to a prior phase, and writing everything down along the way.

Although the waterfall methods is still widely used today, it’s gradually being superseded by more adaptive, flexible methods that produce better software, faster, with less pain. These methods are collectively known as “Agile development.”

It is important to understand that the SDLC can be applied many different ways. Its phases can be repeated, and the order reversed. Individual phases can be performed at many levels in parallel (for example, requirements can be gathered separately for user interface details, back-end integrations, operating and performance parameters, etc.).

We’ll look at the phases of the SDLC in greater detail, and in their classic order (just remember: this is a description, not a prescription)

Requirements and Analysis Phase

The goal of the requirements and analysis phase is to answer several tiers of questions. These begin with exploring stakeholders’ current situation, needs and constraints, present infrastructure, etc. They are determining what problem(s) this new software needs to solve.

After the problem is better-defined, more concrete issues can be explored to determine where, and in what context, the new software will need to live.

When answers to such questions are compiled, it’s time to begin exploring more precise requirements by focusing on desired features and user experience (UX).

Finally, the team begins assessing architectural options for building the software itself. For most enterprise applications, this means many iterations of defining requirements for the software’s front end and back end. You will also need to provide points of integration for other applications, as well as services for lifecycle management.

After gathering the requirements, the team analyzes the results to determine the following:

  • Is it possible to develop the software according to these requirements, and can it be done on-budget?
  • Are there any risks to the development schedule, and if so, what are they?
  • How will the software be tested?
  • When and how will the software be delivered?

At the conclusion of this phase, the classic waterfall method suggests creating a Software Requirement Specification (SRS) document which states the software requirements and scope, and confirms this meticulously with stakeholders.

Design and Implementation Phases


The design phase classically takes the SRS document from the Requirements & Analysis phase as input. During the design phase, the software architects and developers design the software based on the provided SRS.

At the conclusion of the design phase, the team creates High-Level Design (HLD) and Low-Level Design (LLD) documents. The HLD gives a “10,000-foot view” of the proposed software. It describes the general architecture, components and their relationships, and may provide additional detail. The LLD, based on the HLD document, describes in much greater detail the architecture of individual components, the protocols used to communicate among them, and enumerates required classes and other aspects of the design.


The implementation phase classically takes the HLD and the LLD from the design phase as an input.

The implementation phase is often called the coding or development phase. During this phase, the developers take the design documentation and develop the code according to that design. All of the components and modules are built during this phase, which makes implementation the longest phase of the life cycle. During this phase, testing engineers are also writing the test plan.

At the conclusion of the implementation phase, functional code that implements all of the customer’s requirements is ready to be tested.

Testing, Deployment, and Maintenance Phases


The testing phase classically takes the software code from the implementation phase as input. During this phase, the test engineers take the code and install it into the testing environment so they can follow the test plan. The test plan is a document that includes a list of every single test to be performed in order to cover all of the features and functionality of the software, as specified by the customer requirements. In addition to functional testing, the test engineers also perform:

  • Integration testing
  • Performance testing
  • Security testing

When code doesn’t pass a test, the test engineer identifies the bug, which gets passed to the developers. After the bug is fixed, the test engineers will re-test the software. This back and forth between the test and development engineers continues until all of the code passes all of the tests.

At the conclusion of the testing phase, a high quality, bug-free, working piece of software is ready for production, in theory. In practice, this rarely happens. Developers have learned how to test more efficiently, how to build testing into automated workflows, and how to test software at many different levels of detail and abstraction: from the tiniest of low-level function definitions to large-scale component aggregations. They’ve also learned that software is never bug-free, and must instead be made observable, tested in production, and made resilient so it can remain available and perform adequately, despite issues.


The deployment phase takes the software from the testing phase as input. During the deployment phase, the software is installed into the production environment. If there are no deployment issues, the product manager works with the architects and qualified engineers to decide whether the software is ready to be released.

At the end of the deployment phase, the final piece of software is released to customers and other end users.


During the maintenance phase, the team:

  • Provides support for customers
  • Fixes bugs found in production
  • Works on software improvements
  • Gathers new requests from the customer

At the conclusion of the maintenance phase, the team is ready to work on the next iteration and version of the software, which brings the process back to the beginning of the SDLC and the requirements and analysis phase.

Written by isal

2 September 2021 pada 11:48

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout /  Ubah )

Foto Google

You are commenting using your Google account. Logout /  Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout /  Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout /  Ubah )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d blogger menyukai ini: