Software is a complex product that is developed and delivered through a series of steps. Software, like all products, starts as an idea.

What is SDLC?

Software Development Life Cycle (SDLC) is the terminology used to explain how software is delivered to a customer in a series of steps. These steps take software from the ideation phase to delivery.

Whether a document, diagram or working software, the artifact created in the first step becomes the input to the next step. Eventually, the software is delivered to the customer. The sequence of steps used by these methods is commonly referred to as the Software Development Lifecycle (SDLC.)

Seven Phases of the SDLC

These steps are roughly the same from one methodology to another. They tend to occur in this order, though they can also be mixed, such that several steps occur in parallel.

As we’ll discuss later, Agile methods tend to “wind together” all of these steps into a tight, rapidly-repeating cycle. Waterfall methods tend to take each of these steps in turn. Outputs from one become inputs to the following step.

1. Planning

The planning phase involves aspects of project and product management. This may include:

• Resource allocation (both human and materials)
• Capacity planning
• Project scheduling
• Cost estimation
• Provisioning

The outputs of the planning phase include project plans, schedules, cost estimations, and procurement requirements. Ideally, Project Managers and Development staff collaborate with Operations and Security teams to ensure all perspectives are represented.

2. Requirements

The business must communicate with IT teams to convey their requirements for new developments and enhancements. The requirement phase gathers these requirements from business stakeholders and Subject Matter Experts (SMEs.)

Architects, Development teams, and Product Managers work with the SMEs to document the business processes that need to be automated through software. The output of this phase in a Waterfall project is usually a document that lists these requirements. Agile methods, by contrast, may produce a backlog of tasks to be performed.

Read: How to create SRS using requirements to ensure a successful development process.

3. Design and prototyping

Once the requirements are understood, software architects and developers can begin to design the software. The design process uses established patterns for application architecture and software development. Architects may use an architecture framework such as TOGAF to compose an application from existing components, promoting reuse and standardization.

Developers use proven Design Patterns to solve algorithmic problems consistently. This phase may also include some rapid prototyping, also known as a spike, to compare solutions and find the best fit. The output of this phase includes:

• Design documents that list the patterns and components selected for the project
• Code produced by spikes used as a starting point for the development

4. Software development

This phase produces the software under development. Depending on the methodology, this phase may be conducted in time-boxed “sprints” (Agile) or may proceed as a single block of effort (Waterfall). Regardless of methodology, development teams should produce working software as quickly as possible. Business stakeholders should be engaged regularly, to ensure that their expectations are being met. The output of this phase is testable, functional software.

5. Testing

The testing phase of the SDLC is arguably one of the most important. It is impossible to deliver quality software without testing. There is a wide variety of testing necessary to measure quality:

• Code quality
• Unit testing (functional tests)
• Integration testing
• Performance testing
• Security testing

The best way to ensure that tests are run regularly, and never skipped for expediency, is to automate them. Tests can be automated using Continuous Integration tools, like Codeship, for example. The output of the testing phase is functional software, ready for deployment to a production environment.

6. Deployment

The deployment phase is, ideally, a highly automated phase. In high-maturity enterprises, this phase is almost invisible; software is deployed the moment it is ready. However, enterprises with lower maturity or highly regulated industries require some manual approvals for the process. Notwithstanding, even in those cases, the deployment should be fully automated in a continuous deployment model.

Application Release Automation (ARA) tools are used in medium and large-size enterprises to automate the deployment of applications to production environments. ARA systems are usually integrated with Continuous Integration tools. Now we have working software.

7. Operations and maintenance

The operations and maintenance phase is the “end of the beginning,” so to speak. The Software Development Life Cycle doesn’t end here. The software must be monitored constantly to ensure proper operation. Bugs and defects discovered in Production must be reported and responded to, which often feeds work back into the process. Bug fixes may not flow through the entire cycle, however, at least an abbreviated process is necessary to ensure that the fix does not introduce other problems (known as a regression.)

Benefits of the SDLC

Without some kind of structured plan, software development teams tend to devolve into a “herd of cats.” Developers don’t know what they’re supposed to create. Project managers have no idea how much progress is made towards the completion of a project. Without a plan, the business doesn’t even have a way to decide whether the final product meets their requirements.

A formally defined method for software development in the form of the SDLC achieves several benefits:

• A common vocabulary for each step
• Defined communication channels between development teams and stakeholders
• Clear roles and responsibilities among developers, designers, business analysts, and project managers
• Clearly-defined inputs and outputs from one step to the next
• A deterministic “definition of done” that can be used to confirm whether a step is truly complete