TOPIC 2
UNDERSTAND THE SOFTWARE DEVELOPMENT PROCESS
Introduction
Building software is a huge job, which is why digital product teams rely on the software
development life cycle (SDLC). The SDLC usually takes the form of one of 5 different
methodologies and follows 7 main development stages. Knowing what needs to be done in the
SDLC process can help product managers guide the entire project to completion.
What is the SDLC?
The software development life cycle is a process that development teams use to create awesome
software that's top-notch in terms of quality, cost-effectiveness, and time efficiency. The main goal
is to minimize risks long before deciding how to launch your Software product and ensure the
software meets the customer's expectations during and after production.
This process is about creating a detailed plan to guide the development of the product and then
breaking down the development process into smaller modules that can be assigned, completed,
and measured to make the whole thing more manageable.
Here are some specific benefits of using SDLC for the product team:
• Increased visibility of the development process for all stakeholders involved
• More efficient estimation, planning, and scheduling
• Improved risk management and cost estimation
• A systematic approach to delivering software that meets customer expectations and
improves satisfaction
THE 7 PHASES OF THE SOFTWARE DEVELOPMENT LIFE CYCLE
1. Planning Stage/problem recognition& definition definition/ Initiation Phase (What
Are the Existing Problems?)
This phase helps identify how a specific problem can be solved with a certain software solution.
This stage lays the groundwork for the entire SDLC. It involves identifying the system’s goals,
defining project scope, setting objectives, establishing timelines, and determining available
resources. Planning ensures that the development process aligns with organizational needs and sets
a clear direction for subsequent stages. The purposes of the Initiation Phase are to:
• Identify significant assumptions and constraints on solutions to that need
• Recommend the exploration of alternative concepts and methods to satisfy the need.
2. Feasibility study/ Define Requirements/information gathering
The Feasibility Phase is the initial investigation, or brief study of the problem to determine whether
the systems project should be pursued. A feasibility study establishes the context through which
the project addresses the requirements expressed in the Business Case and investigates the
practicality of a proposed solution. The feasibility study is used to determine if the project should
get the go-ahead. If the project is to proceed, the feasibility study will produce a project plan and
budget estimates for the future stages of development.
3. Systems Requirements and Analysis Phase (What Do We Want?)
During the Analysis stage, the focus is on gathering and understanding the requirements of the
system. This includes conducting interviews, studying existing processes, and identifying
stakeholders’ needs. The gathered information serves as a basis for designing a system that meets
users’ expectations and addresses organizational challenges. The purposes of this phase are to:
• Complete business process reengineering of the functions to be supported, e.g., verify what
information drives the business process, what information is generated, who generates it,
where does the information go, and who processes it.
• Develop detailed data and process models including system inputs and outputs.
• Develop the test and evaluation requirements that will be used to determine acceptable
system performance.
4. System Design (What Will the Finished Project Look Like?)
System Design is a critical stage in the SDLC, where the requirements gathered during the Analysis
phase are translated into a detailed technical plan. It involves designing the system’s architecture,
database structure, and user interface, and defining system components. The Design stage lays the
foundation for the subsequent development and implementation phases. Since problems in the
design phase can be very expensive to solve in later stages of the software development, a variety
of elements are considered in the design to mitigate risk. These include:
• Identifying potential risks and defining mitigating design features
• Performing a security risk assessment
• Developing a conversion plan to migrate current data to the new system
• Determining the operating environment
• Defining major subsystems and their inputs and outputs
• Allocating processes to resources
5. System development (Let’s Create the System)
The Development stage involves the actual coding and programming of the system. Based on the
design specifications, developers write code, create database structures, and implement necessary
functionalities. Rigorous testing and quality assurance are performed to ensure the system’s
accuracy, performance, and adherence to the design requirements. The Development phase
consists of:
• Translating the detailed requirements and design into system components
• Testing individual elements (units) for usability
• Preparing for integration and testing of the IT system.
Integration, system, security, and user acceptance testing is conducted during this phase as well.
The user, with those responsible for quality assurance, validates that the functional requirements
are met by the newly developed or modified system. Developers will typically use multiple tools,
programming environments, and languages (C++, PHP, Python, and others), all of which will
comply with the project specifications and requirements outlined in the SRS document.
6. System Integration and implementation/ System Deployment (How Will We Use It?)
This stage involves deploying the developed system into the production environment. This
includes activities such as system installation, data migration, training end-users, and configuring
necessary infrastructure. Implementation requires careful planning and coordination to minimize
disruptions and ensure a smooth transition from the old system to the new one.
7. System maintenance and Review (Let’s Make the Improvements)
Maintenance is an ongoing stage that involves monitoring, managing, and enhancing the system’s
performance and functionality. It includes activities such as bug fixes, updates, security patches,
and addressing user feedback. Regular maintenance ensures the system remains reliable, secure,
and adaptable to changing business needs.
SOFTWARE DEVELOPMENT METHODOLOGIES
Now that you know the basic SDLC phases and why each of them is important, it’s time to dive
into the core methodologies of the system development life cycle.
These are the approaches that can help you to deliver a specific software model with unique
characteristics and features. Most developers and project managers opt for one of
these approaches. Hybrid models are also popular. These system development life cycle models
include:
i. Waterfall Model
ii. Iterative Model
iii. Evolutionary Model
iv. Prototype Model
v. Spiral Model
vi. RAD Model
vii. Agile Model
viii. Incremental Model
Waterfall Model:
The Waterfall model also known as linear-sequential life cycle model, is the earliest SDLC
approach that was used for software development.The waterfall Model illustrates the software
development process in a linear sequential flow. This means that any phase in the development
process begins only if the previous phase is complete. In this waterfall model, the phases do not
overlap. In "The Waterfall" approach, the whole process of software development is divided into
separate phases and the outcome of one phase acts as the input for the next phase sequentially.
Each stage must be completed before the next one can begin, and extensive documentation is
required to ensure that all tasks are completed before moving on to the next stage.
Requirement Gathering and analysis - All possible requirements of the system to be developed
are captured in this phase and documented in a requirement specification document.
System Design -The requirement specifications from first phase are studied in this phase and the
system design is prepared. This system design helps in specifying hardware and system
requirements and helps in defining the overall system architecture.
Implementation - With inputs from the system design, the system is first developed in small
programs called units, which are integrated in the next phase. Each unit is developed and tested
for its functionality, which is referred to as Unit Testing.
Integration and Testing - All the units developed in the implementation phase are integrated into
a system after testing of each unit. Post integration the entire system is tested for any faults and
failures.
Deployment of system - Once the functional and non-functional testing is done; the product is
deployed in the customer environment or released into the market.
Maintenance - There are some issues which may come up in the client environment. To fix those
issues, patches are released to enhance the product. Maintenance is done to deliver these changes
in the customer environment.
Circumstances where waterfall model may be appropriate for use
Where:
a. Requirements are very well documented, clear and well defined.
b. Product definition is stable.
c. Technology is understood and is not dynamic.
d. There are no ambiguous requirements.
e. Ample resources with required expertise are available to support the product.
f. The project is short.
Advantages of the waterfall model
a. Simple and easy to understand and use
b. Easy to manage due to the rigidity of the model. Each phase has specific
deliverables and a review process.
c. Phases are processed and completed one at a time.
d. Works well for smaller projects where requirements are very well understood.
e. Clearly defined stages.
f. Well understood milestones.
g. Easy to arrange tasks.
h. Process and results are well documented.
Disadvantages of using the waterfall model
a. No working software is produced until late during the life cycle.
b. High amounts of risk and uncertainty.
c. Not a good model for complex and object-oriented projects.
d. Poor model for long and ongoing projects.
e. Not suitable for the projects where requirements are at a moderate to high risk of
changing. So, risk and uncertainty is high with this process model.
f. It is difficult to measure progress within stages.
g. Cannot accommodate changing requirements.
h. Adjusting scope during the life cycle can end a project.
i. Integration is done as a "big-bang. at the very end, which doesn't allow identifying
any technological or business bottleneck or challenges early.
2.Prototype model
The basic idea in Prototype model is that instead of freezing the requirements before a design or
coding can proceed, a throwaway prototype is built to understand the requirements.
This prototype is developed based on the currently known requirements. Prototype model is a
software development model where, the client can get an “actual feel” of the system, since the
interactions with prototype can enable the client to better understand the requirements of the
desired system. Prototyping is an attractive idea for complicated and large systems for which there
is no manual process or existing system to help determining the requirements. The prototype are
usually not complete systems and many of the details are not built in the prototype. The goal is to
provide a system with overall functionality.
Advantages of the prototype model
i. Users are actively involved in the development
ii. Since in this methodology a working model of the system is provided, the users get a better
understanding of the system being developed.
iii. Errors can be detected much earlier.
iv. Quicker user feedback is available leading to better solutions.
v. Missing functionality can be identified easily
Disadvantages of the prototype model
Practically, this methodology may increase the complexity of the system as scope of the system
may expand beyond original plans.
Circumstances when the use of prototype model is appropriate:
a. Prototype model should be used when the desired system needs to have a lot of interaction
with the end users.
b. Typically, online systems, web interfaces have a very high amount of interaction with end
users, are best suited for Prototype model. It might take a while for a system to be built that
allows ease of use and needs minimal training for the end user.
c. Prototyping ensures that the end users constantly work with the system and provide a
feedback which is incorporated in the prototype to result in a useable system. They are
excellent for designing good human computer interface systems.
Iterative Model:
An iterative life cycle model does not attempt to start with a full specification of requirements.
Instead, development begins by specifying and implementing just part of the software, which can
then be reviewed in order to identify further requirements. This process is then repeated, producing
a new version of the software for each cycle of the model.
Example:
In the diagram above, when we work iteratively we create rough product or product piece in one
iteration, then review it and improve it in next iteration and so on until it’s finished. As shown in
the image above, in the first iteration the whole painting is sketched roughly, then in the second
iteration colors are filled and in the third iteration finishing is done. Hence, in iterative model the
whole product is developed step by step. . The basic idea behind this method is to develop a system
through repeated cycles (iterative) and in smaller portions at a time (incremental).
The Iterative model is often favored because it is adaptable, and changes are comparatively easier
to accommodate.
Iterative Model Pros and Cons
The advantage of this model is that there is a working model of the system at a very early stage of
development which makes it easier to find functional or design flaws. Finding issues at an early
stage of development enables to take corrective measures in a limited budget.
The disadvantage with this SDLC model is that it is applicable only to large and bulky software
development projects. This is because it is hard to break a small software system into further small
serviceable increments/modules.
Spiral Model:
spiral model is a combination of iterative development process model and sequential linear
development model i.e. waterfall model with very high emphasis on risk analysis. It allows for
incremental releases of the product, or incremental refinement through each iteration around the
spiral.
Spiral model design
The spiral model has four phases. A software project repeatedly passes through these phases in
iterations called Spirals.
1. Identification
This phase starts with gathering the business requirements in the baseline spiral. In the subsequent
spirals as the product matures, identification of system requirements, subsystem requirements and
unit requirements are all done in this phase. This also includes understanding the system
requirements by continuous communication between the customer and the system analyst. At the
end of the spiral the product is deployed in the identified market.
2. Design
Design phase starts with the conceptual design in the baseline spiral and involves architectural
design, logical design of modules, physical product design and final design in the subsequent
spirals.
3. Construct or Build
Construct phase refers to production of the actual software product at every spiral. In the baseline
spiral when the product is just thought of and the design is being developed a POC (Proof of
Concept) is developed in this phase to get customer feedback. Then in the subsequent spirals with
higher clarity on requirements and design details a working model of the software called build is
produced with a version number. These builds are sent to customer for feedback.
4. Evaluation and Risk Analysis
Risk Analysis includes identifying, estimating, and monitoring technical feasibility and
management risks, such as schedule slippage and cost overrun. After testing the build, at the end
of first iteration, the customer evaluates the software and provides feedback. Based on the customer
evaluation, software development process enters into the next iteration and subsequently follows
the linear approach to implement the feedback suggested by the customer. The process of iterations
along the spiral continues throughout the life of the software.
Spiral Model Application
Spiral Model is very widely used in the software industry as it is in synch with the natural
development process of any product i.e. learning with maturity and also involves minimum risk
for the customer as well as the development firms.
The following are scenarios when the Spiral model is applied:
a. When there is a budget constraint and risk evaluation is important
b. For medium to high-risk projects
c. Long-term project commitment because of potential changes to economic priorities as the
requirements change with time
d. Customer is not sure of their requirements which is usually the case
e. Requirements are complex and need evaluation to get clarity
f. New product line which should be released in phases to get enough customer feedback
g. Significant changes are expected in the product during the development cycle
Advantages of spiral model
a. Changing requirements can be accommodated.
b. Allows for extensive use of prototypes
c. Requirements can be captured more accurately.
d. Users see the system early.
e. Development can be divided into smaller parts and more risky parts can be developed
earlier which helps better risk management.
Disadvantages of spiral model
a. Management is more complex.
b. End of project may not be known early.
c. Not suitable for small or low risk projects and could be expensive for small projects.
d. Process is complex
e. Spiral may go indefinitely.
f. Large number of intermediate stages requires excessive documentation.
Rapid Application Development model
Rapid application development (RAD) is a software development methodology that uses minimal
planning in favor of rapid prototyping. A prototype is a working model that is functionally
equivalent to a component of the product. In RAD model the functional modules are developed in
parallel as prototypes and are integrated to make the complete product for faster product delivery.
Since there is no detailed preplanning, it makes it easier to incorporate the changes within the
development process. RAD projects follow iterative and incremental model and have small teams
comprising of developers, domain experts, customer representatives and other IT resources
working progressively on their component or prototype. The most important aspect for this model
to be successful is to make sure that the prototypes developed are reusable.
Rad model design
RAD model distributes the analysis, design, build, and test phases into a series of short, iterative
development cycles. The following are the phases of RAD Model
Business Modeling:
The business model for the product under development is designed in terms of flow of information
and the distribution of information between various business channels. A complete business
analysis is performed to find the vital information for business, how it can be obtained, how and
when is the information processed and what are the factors driving successful flow of information.
Data Modeling:
The information gathered in the Business Modeling phase is reviewed and analyzed to form sets
of data objects vital for the business. The attributes of all data sets is identified and defined. The
relation between these data objects are established and defined in detail in relevance to the business
model.
Process Modeling:
The data object sets defined in the Data Modeling phase are converted to establish the business
information flow needed to achieve specific business objectives as per the business model. The
process model for any changes or enhancements to the data object sets is defined in this phase.
Process descriptions for adding , deleting, retrieving or modifying a data object are given.
Application Generation:
The actual system is built and coding is done by using automation tools to convert process and
data models into actual prototypes.
Testing and Turnover:
The overall testing time is reduced in RAD model as the prototypes are independently tested during
every iteration. However the data flow and the interfaces between all the components need to be
thoroughly tested with complete test coverage. Since most of the programming components have
already been tested, it reduces the risk of any major issues.
Where RAD is applied
RAD model can be applied successfully to the projects in which clear modularization is possible.
If the project cannot be broken into modules, RAD may fail. The following are the typical scenarios
where RAD can be used:
a. RAD should be used only when a system can be modularized to be delivered in incremental
manner.
b. It should be used if there’s high availability of designers for modeling
c. It should be used only if the budget permits use of automated code generating tools.
d. RAD SDLC model should be chosen only if domain experts are available with relevant
business knowledge
e. Should be used where the requirements change during the course of the project and
working prototypes are to be presented to customer in small iterations of 2- 3 months.
Advantages of RAD
• Changing requirements can be accommodated.
• Progress can be measured.
• Iteration time can be short with use of powerful RAD tools.
• Productivity with fewer people in short time.
• Reduced development time.
• Increases reusability of components
• Quick initial reviews occur
• Encourages customer feedback
• Integration from very beginning solves a lot of integration issues.
Disadvantages of RAD
• Dependency on technically strong team members for identifying business requirements.
• Only system that can be modularized can be built using RAD
• Requires highly skilled developers/designers.
• High dependency on modeling skills
• Inapplicable to cheaper projects as costof modeling and automated code generation is very
high. Management complexity is more.
• Suitable for systems that are component based and scalable.
• Requires user involvement throughout the life cycle.
• Suitable for project requiring shorter development times.
AGILE MODEL
Agile Methods break the product into small incremental builds. These builds are provided in
iterations. Each iteration typically lasts from about one to three weeks. Every iteration involves
cross functional teams working simultaneously on various areas like planning, requirements
analysis, design, coding, unit testing, and acceptance testing. At the end of the iteration a working
product is displayed to the customer and important stakeholders.
Agile model believes that every project needs to be handled differently and the existing methods
need to be tailored to best suit the project requirements. In agile the tasks are divided to time boxes
(small time frames) to deliver specific features for a release. Iterative approach is taken and
working software build is delivered after each iteration. Each build is incremental in terms of
features; the final build holds all the features required by the customer.
Agile manifesto principles
Individuals and interactions – in agile development, self-organization and motivation are
important, as are interactions like co-location and pair programming.
Working software – Demo working software is considered the best means of communication
with the customer to understand their requirement, instead of just depending on documentation.
Customer collaboration – As the requirements cannot be gathered completely in the beginning
of the project due to various factors, continuous customer interaction is very important to get
proper product requirements.
Responding to change – agile development is focused on quick responses to change and
continuous development.
Advantages of Agile model
• Is a very realistic approach to software development
• Promotes teamwork and cross training.
• Functionality can be developed rapidly and demonstrated.
• Resource requirements are minimum.
• Suitable for fixed or changing requirements
• Delivers early partial working solutions.
• Good model for environments that change steadily.
• Minimal rules, documentation easily employed.
• Enables concurrent development and delivery within an overall planned context.
• Little or no planning required
• Easy to manage
• Gives flexibility to developers
Disadvantages of Agile Model
• Not suitable for handling complex dependencies.
• More risk of sustainability, maintainability and extensibility.
• An overall plan, an agile leader and agile PM practice is a must without which it will not
work.
• Strict delivery management dictates the scope, functionality to be delivered, and
adjustments to meet the deadlines.
• Depends heavily on customer interaction, so if customer is not clear, team can be driven in
the wrong direction.
• There is very high individual dependency, since there is minimum documentation
generated.
• Transfer of technology to new team members may be quite challenging due to lack of
documentation.
