You have an ingenious idea for software. What's next? How do you transform what's in your head into a real product that people can use?
This is where SDLC or Software Development Lifecycle comes into play. SDLC is the process of building and maintaining software.
There are different models of SDLC. Although different in application, they all seek to reduce time, cost and develop the highest quality software in their own way.
Whether it's a big IT enterprise, a small startup, or a software development agency; every team uses an SDLC model. Before we learn more about them, let's look at the basic SDLC framework that is consistent across all models.
6 Stages of SDLC
What are we going to build? Why? For whom? These are the fundamental questions that development teams ask before embarking on any project. It tries to understand customer requirements and proposes a solution.
The team refines its proposed solution based on customer feedback. It then chalks out a plan that allows everyone to understand the scope of the project and its estimated delivery time. It's important to involve all the people who'll work on the project in the planning phase - developers, designers, product managers, and of course the customers.
A lot of software development projects fail because of mistakes during the planning phase. It's important to not take customer requirements verbatim but to truly understand the core problem that they want to solve.
After the customer approves the plan, the design work and prototyping of the software begin. A prototype is an early-stage conceptual model of the software. It gives a rudimentary overview of the software's UI/UX. The customer feedback at this stage is priceless because it's a lot less expensive to make changes here than when actual development begins.
This stage involves more than just visual design. The team also decides what technology stack (programming language, platform, tools) it will use. It will take decisions on matters that aren't apparent to non-IT customers, such as security, backend infrastructure, etc.
Similar to the previous step, the customer approves the prototype and the development team proceeds to the next step.
This is where the bulk of coding takes place. The development team starts working on building the software, feature by feature. It also continuously solves bugs that pop up and maintains documentation of the process.
The involvement of customers at this stage depends on the SDLC model that the team adopts (more on that in a bit). Ideally, customers are kept in the loop during the implementation stage so that they can see their idea come to life and continue giving feedback.
It's common during this stage for the development team to deviate from certain aspects of the prototype. This might be due to encountering certain technical issues or figuring out a more elegant solution. It's impossible to foresee all technical challenges for the software during the design stage. However, all changes are incorporated only with the agreement of the customer.
No software is deployed to users prior to testing. Testing is of two types:
- Automated - Developers create programs to run tests automatically such as security and scalability tests. For example, they themselves try to bombard the application with fake users to check how stable it is. They'll do penetration tests to see how susceptible the software is to security breaches.
- Manual - Developers play with different features of the software to see if they work as intended. This is done in a testing environment, i.e. the features are not live for users but only for the development team.
In most development teams, QA (Quality Assurance) engineers are accountable for overall testing. However, testing isn't solely their responsibility. All developers are involved in it.
Nowadays, most development teams don't wait to finish all the features before testing them. It happens simultaneously during the implementation stage.
The deployment stage is when the software goes from testing environment to production. It becomes available to all users.
How the software is deployed depends on both the business requirements and the technical infrastructure. For example, customers might choose to deploy the software to a limited set of users to minimize risk and get more feedback before a full-blown release. In most cases, the deployment process is fully automated. Modern startups deploy multiple releases on a daily basis.
At the end of the deployment stages, users can interact with the software.
The SDLC process doesn't end with deployment. Remember, it's Software Development Lifecycle, i.e. a continuous process.
Software nowadays are living entities. They don't stay stagnant. They keep evolving based on user feedback. The technology keeps evolving, so does the user requirements. The maintenance phase helps software keep up with the times.
The development team addresses bugs and continuously upgrade the software. That's why you see frequent updates to both your mobile and web-based apps.
During the maintenance phase, the team might decide to work on a new set of features. This would then take them back to the first step of the SDLC - planning. And the cycle will continue.
Popular SDLC Models
We discussed the six basic phases of SDLC. But how are they implemented?
There are various models that organizations can pick:
- Big Bang
There are plenty more. We won't discuss all of them but two of the most popular ones - Waterfall and Agile.
The Waterfall model is exactly how you'd picture the SDLC phases would be adopted.
It's the earliest SDLC model. In fact, Waterfall is being used by mankind to run manufacturing and construction projects for centuries. So when software engineering first started, it was only natural for teams to adopt it.
In the Waterfall model, the SDLC steps are completed in a sequential manner. Each stage only begins when all the deliverables of the previous phase are completed. Hence the name waterfall, because the progress is steadily flowing downwards.
For example, when the prototype is approved, the development team works on creating a working software that meets the requirements of the prototype. After that, it sends the results to the customer for feedback.
There is extensive planning and documentation in Waterfall because it's highly expensive to change requirements in the middle of SDLC.
Software engineering is very different from mechanical engineering. The trends in IT change rapidly and client requirements might change completely if it takes too long to build the product.
In 2001, a group of developers frustrated by the rigid structure of the Waterfall model created the Agile Manifesto. This specifically aimed to create a new model that could be adapted to changing requirements even during the later stages of SDLC.
Agile encourages continuous interaction with customers through all the stages of SDLC. SDLC is broken down into smaller cycles. At the end of each cycle, the team delivers a working solution that can be experienced by the customers. The team takes customer feedback into account for the next iteration.
In simple words, Agile is a mindset change where the team prioritizes customer satisfaction above everything else by optimizing SDLC for changing requirements.
If you would like to transform your idea into an app and learn more about SDLC, get in touch with us for free consultation.