Case Study Based On Sdlc Model

This tutorial explains in detail the Software/System Development Life Cycle (SDLC) like the Waterfall cycle & Iterative cycle like RAID & Agile. And further, it proceeds to explain the V-Model of testing and STLC (Software Test Life Cycle).

Please be patient. The Video will load in some time. If you still face issue viewing video click here

Suppose, you are assigned a task, to develop a custom software for a client. Now, irrespective of your technical background, try and make an educated guess about the sequence of steps you will follow, to achieve the task.

The correct sequence would be.

Different phases of Software Development Cycle

Activities performed in each stage

Requirement Gathering stage
  • Gather as much information as possible about the details & specifications of the desired software from the client. This is nothing but the Requirements gathering stage.
Design Stage
  • Plan the programming language like Java, PHP, .net; database like Oracle, MySQL, etc. Which would be suited for the project, also some high-level functions & architecture.
Build Stage
  • After design stage, it is build stage, that is nothing but actually code the software
Test Stage
  • Next, you test the software to verify that it is build as per the specifications given by the client.
Deployment stage
  • Deploy the application in the respective environment
Maintenance stage
  • Once your system is ready to use, you may require to change the code later on as per customer request

All these levels constitute the waterfall method of software development lifecycle. As you may observe, that testing in the model starts only after implementation is done.

But if you are working in the large project, where the systems are complex, it's easy to miss out the key details in the requirements phase itself. In such cases, an entirely wrong product will be delivered to the client and you might have to start afresh with the project OR if you manage to note the requirements correctly but make serious mistakes in design and architecture of your software you will have to redesign the entire software to correct the error.

Assessments of thousands of projects have shown that defects introduced during requirements & design make up close to half of the total number of defects.

Also, the costs of fixing a defect increases across the development life cycle. The earlier in life cycle a defect is detected, the cheaper it is to fix it. As the say, "A stitch in time saves a nine."

To address this concern, the V model of testing was developed where for every phase, in the Development life cycle there is a corresponding Testing phase

  • The left side of the model is Software Development Life Cycle - SDLC
  • The right side of the model is Software Test Life Cycle - STLC
  • The entire figure looks like a V, hence the name V - model

Apart from V model, there are iterative development models, where development is carried in phases, with each phase adding a functionality to the software. Each phase comprises of its independent set of development and testing activities.

Good examples of Development lifecycles following iterative method are Rapid Application Development, Agile Development

Here are the Key Terms again:

  • SDLC:
  • SDLC is Software Development Life Cycle. It is the sequence of activities carried out by Developers to design and develop high-quality software.

    Though SDLC uses the term ‘Development’, it does not involve just coding tasks done by developers but also incorporates the tasks contributed by testers and stakeholders.

    In SDLC, test cases are created.

  • STLC:
  • STLC is Software Testing Life Cycle. It consists of series of activities carried out by Testers methodologically to test your software product.

    Though STLC uses the term “testing” it does not involve just testers, at some instances, they have to involve developers as well.

    In STLC Test cases are executed.

  • Waterfall Model:
  • Waterfall model is a sequential model divided into different phases of software development activity. Each stage is designed for performing specific activity during SDLC phase. Testing phase in waterfall model starts only after implementation of the system is done.

    Testing is done within the SDLC.

  • V- Model:
  • V- model is an extension of the waterfall model. Unlike waterfall model, In V-model, there is a corresponding testing phase for each software development phase. Testing in V-model is done in parallel to SDLC stage.

    Testing is done as a sub project of SDLC.


There are numerous development life cycle models. Development model selected for a project depends on the aims and goals of that project.

  • Testing is not a stand-alone activity, and it has to adapt the development model chosen for the project.
  • In any model, testing should performed at all levels i.e. right from requirements until maintenance.


To build good-quality software you need to fully understand the essentials of software development life cycle (SDLC), customer’s requirements to the delivered product as well as customer’s budgets. There’s a number of life-cycle model types (waterfall model, spiral model, kanban development model, rapid prototyping, scrum model, etc). Selection of a particular type of life-cycle model depends largely on your project scope and stakes.

As a rule, we adhere to using the spiral model that involves agile development methodologies. However, sometimes we use a Waterfall model and its derivatives for small and trivial projects, when applicable. In this article, we’ll describe the Waterfall model as the classic SDLC type.

Following this model type, a project is implemented step-by-step in accordance with the precise sequence: requirements gathering and study, software design, software development, software testing and software maintenance. The Waterfall model is flexible and some phases can intersect.

Let’s consider all life-cycle phases one by one.

Software Development Life Cycle: Waterfall Model Stages

1. Requirements Analysis (Requirements Phase)

At this phase it is important to document all requirements to the desired software. You should dedicate sufficient time to this phase, conducting extensive interviews with stakeholders. It is better to structure all incoming data, analyze them, consider all technical limitations that may arise on the client’s side, and come out with a ready-to-follow specification to meet the client’s needs. Another thing to consider is any constraints that may hinder the development process, such as client’s time and budget constraints.

Note: The more detailed information about the bespoke project you get, the less time you will spend on fixes, redesigns, budget reviews, discussions and other issues.


Vision Document

It is highly recommended that you create a detailed problem vision document, specifying the problem background, business goals and success criteria for the project, factors of business risk and description of the product end-user group.

Then share it with the client to make sure you do understand the client’s needs in the right way and inform the client about any risks that may arise after the project is launched.


Requirements Gathering

When all issues seem to be clarified, it is highly recommended that you conduct more interviews and interactive workshops with your stakeholders to elicit some non-obvious things that may further cause redesigning of software interface or rewriting some code patterns. This phase can also involve questionnaires, use cases, brainstorming, etc.

Many projects are sidetracked because of additional requirements that arise on the development phase. That’s why it is highly important that you understand the initial business goals and the primary idea of the future application.

2. Software Design Phase

The next step in the life-cycle involves creation of a project scope document with mockups, or hand-drawn sketches, and a detailed software development specification. It should be mentioned that in some cases vision and scope documents can be presented as one Vision and Scope document.


Project Scope

The project scope document should include project description with main functions defined with regard to the problem vision document, and, of course, timeline and bugets.

It also involves creation of mockups, or hand-drawn sketches, based upon the vision document and gathered requirements.

You can create a hand-drawn sketch of a user interface or use mockup programs, and share it with the client to get a feedback. Here is the list of useful programs to make mockups that we use in our practice:

  • InVision (
  • Webflow (
  • Moqups (

Of course, the client can come up with more and more new ideas for their project the more he thinks about it. Therefore the best advice is to give the client some time to think over the project and its application needs, and then meet and discuss it again to be sure nothing is missed.

At this stage, after-sales product maintenance is also discussed. You should inform the client where any technical support will be rendered after the product is tested and deployed.

Vision and scope documents are created prior to contract signing.

Read more about project scope management in the article written by XB Software expert Vitaly Hornik.


Software Requirements Specification

Software requirements specification (SRS) describes requirements that should be fulfilled within the requested software. It should be cohesive, consistent, traceable and complete. The requirements can be provided in different forms, for example,  as traditional shall statements (e.g. “The Staff Manager system shall support the following browsers: Google Chrome, Apple Safari, Mozilla Firefox, Opera, IE 8+”) or as a user stories (e.g. “as a manager, I need access to personal information of all employees”).

Use Software Requirements Specification (SRS) Template created by XB Software.

There’s a great number of specification templates. Selection of a particular template depends on the specifics of the project. Basically, it includes product description, user classes, functional and non-functional requirements to the developed software.Sometimes, it can include a prototype. The main idea is to make your specification clear, concise and useful for developers.

To create a prototype, you need to figure out the following things:

  • The way the input data will be acquired and processed to produce the desired output data;
  • The form in which the output data should be presented.

Mockups (or prototypes) are sent to UI/UX designers who turn them into colorful layouts.

3. Software Development Life Cycle Phase

It should be noted that software development companies can also include creation of an interactive prototype that is actually the skeleton of the future application. Such prototype helps define the overall system architecture. This step involves little coding, like coding buttons and simple forms, just to give the client an idea how the final product will operate. That’s why we included creation of a prototype into the software development phase.

As soon as you are ready with the interactive prototype and application design and they are confirmed by the client, proceed with working out the application standards (naming conventions, how the code will be documented, formation of end-user instructions, etc.).

Afterwards, you can get down to the next step in the life cycle, namely software development. It can be subdivided into small units, and each unit is developed and tested by developers for its functionality (unit testing).

4. Software Testing Phase

Once the product is developed, it should undergo a meticulous quality assurance and software testing to make sure that it solves the needs set forth during the requirements study phase. The client should be involved in the acceptance testing and try using it exactly the way it will be used when implemented . Once the major code problems are fixed, the software can be deployed. For minor fixes, a simple bug tracking system can be used, so that the problems could be tackled during the maintenance life-cycle phase.

5. Software Maintenance Phase

As soon as the product is tested and deployed at the client’s server, it enters the maintenance phase of the software development life cycle. Generally, it includes some minor bug fixes that are usually made during this phase.

However, you still may have to make some changes in the produced software, disregarding your efforts on the earlier phases. The client may come up with functionality enhancements to the developed software and you will have to collect, describe and discuss the new requirements with the client to have these modifications made. In this case, you come up with a new waterfall project and have to repeat all the above described steps.


These are the core phases inevitable for building quality software. In order to succeed, you have to discuss all requirements to future application with stakeholder and document in detail all work that is done on each project phase.

This model is canonical for military, space, medical and life-critical systems such as flight control software, airbag systems, etc. It can be also used for small and trivial projects. However, if you make a mistake during any of the initial stages, it can be discovered as late as on the final stage of project implementation or testing. That’s why it is recommended to follow this type of model only in case all requirements are clear and won’t change over time.

This article is prepared under the guidance of the experienced business analysts of XB Software.

All posts, Business Analysis, software development

The following two tabs change content below.

XB Software marketing specialist proficient in digital marketing. She is passionate about web marketing and strives to create engaging, web-friendly content for IT audience across a variety of topics.

0 thoughts on “Case Study Based On Sdlc Model

Leave a Reply

Your email address will not be published. Required fields are marked *