Overall Contents:

i. Front Matter
1. Introduction (no more than 1 page)
2. Planning (no more than 1/2 pages)
3. Requirements Analysis (2-4 pages)
4. Design (2-4 pages)
5. Development (code)
6. Testing (no more than 2 pages)
7. Deployment (no more than 1 page)
8. Maintenance (2-4 pages)
9. Conclusion (no more than 1 page)
10. References

The report will have contents related to SEVEN phases of the SDLC. In each phase, you can
consider keeping the highlighted part of the following text. The followings are taken from:
https://www.clouddefense.ai/blog/system-development-life-cycle

7 Stages of the System Development Life Cycle

There are seven primary stages of the modern system development life cycle. Here’s a
brief breakdown:

• Planning Stage

• Feasibility or Requirements of Analysis Stage

• Design and Prototyping Stage

• Software Development Stage

• Software Testing Stage

• Implementation and Integration

• Operations and Maintenance Stage

Now let’s take a closer look at each stage individually.

Planning Stage

Before we even begin with the planning stage, the best tip we can give you is to take
time and acquire proper understanding of app development life cycle.

The planning stage (also called the feasibility stage) is exactly what it sounds like: the
phase in which developers will plan for the upcoming project.

It helps to define the problem and scope of any existing systems, as well as determine
the objectives for their new systems.

By developing an effective outline for the upcoming development cycle, they'll

theoretically catch problems before they affect development.

And help to secure the funding and resources they need to make their plan happen.
Perhaps most importantly, the planning stage sets the project schedule, which can be of
key importance if development is for a commercial product that must be sent to market
by a certain time.

Analysis Stage

The analysis stage includes gathering all the specific details required for a new system
as well as determining the first ideas for prototypes.

Developers may:

• Define any prototype system requirements

• Evaluate alternatives to existing prototypes

• Perform research and analysis to determine the needs of end-users

Furthermore, developers will often create a software requirement specification or SRS

document.

This includes all the specifications for software, hardware, and network requirements for
the system they plan to build. This will prevent them from overdrawing funding or
resources when working at the same place as other development teams.

You can consider drawing any or a few of the diagrams like: UML (Swimlane, Activity,
etc), Flowchart, etc. Use draw.io (https://app.diagrams.net/). You can consult this url:
https://www.guru99.com/requirements-analysis-and-transformation-techniques.html

Design Stage
The design stage is a necessary precursor to the main developer stage.

Developers will first outline the details for the overall application, alongside specific
aspects, such as its:

• User interfaces

• System interfaces

• Network and network requirements

• Databases

They’ll typically turn the SRS document they created into a more logical structure that
can later be implemented in a programming language. Operation, training, and
maintenance plans will all be drawn up so that developers know what they need to do
throughout every stage of the cycle moving forward.

Once complete, development managers will prepare a design document to be

referenced throughout the next phases of the SDLC.

E-R Diagram, Wireframe for UI (use online tool)

Development Stage

The development stage is the part where developers actually write code and build the
application according to the earlier design documents and outlined specifications.

This is where Static Application Security Testing or SAST tools come into play.

Product program code is built per the design document specifications. In theory, all of
the prior planning and outlined should make the actual development phase relatively
straightforward.

Developers will follow any coding guidelines as defined by the organization and utilize
different tools such as compilers, debuggers, and interpreters.

Programming languages can include staples such as C++, PHP, and more. Developers
will choose the right programming code to use based on the project specifications and
requirements.

Attach your code

Testing Stage
Building software is not the end.

Now it must be tested to make sure that there aren’t any bugs and that the end-user
experience will not negatively be affected at any point.

During the testing stage, developers will go over their software with a fine-tooth comb,
noting any bugs or defects that need to be tracked, fixed, and later retested.

t’s important that the software overall ends up meeting the quality standards that were
previously defined in the SRS document.

Depending on the skill of the developers, the complexity of the software, and the
requirements for the end-user, testing can either be an extremely short phase or take a
very long time. Take a look at our top 10 best practices for software testing projects for
more information.

Attach: Test Report

Implementation and Integration Stage

After testing, the overall design for the software will come together. Different modules or
designs will be integrated into the primary source code through developer efforts,
usually by leveraging training environments to detect further errors or defects.

The information system will be integrated into its environment and eventually installed.
After passing this stage, the software is theoretically ready for market and may be
provided to any end-users.
Provide the hosting/online link of your project work.

Maintenance Stage

The SDLC doesn’t end when software reaches the market. Developers must now move
into a maintenance mode and begin practicing any activities required to handle issues
reported by end-users.

Furthermore, developers are responsible for implementing any changes that the
software might need after deployment.

This can include handling residual bugs that were not able to be patched before launch
or resolving new issues that crop up due to user reports. Larger systems may require
longer maintenance stages compared to smaller systems.

User/Instruction Manual