In Biology, the life cycle is the period of time from birth to death. The meaning of the life cycle in software development doesn’t differ much. It embraces all the stages of product existence, from an intention to create a new software solution to an end of using it. Software behaves similarly to a living organism: it appears, evolves, faces difficulties, and sooner or later ends the functioning. For now, let’s try to figure out the basics of the life of software and the role of testing in this process.
To start with, what is SDLC? Here’s a simple software development life cycle definition: it is a period, which starts with making a decision that a new software product is necessary and ends when the product is no longer used. Explaining SDLC meaning in simple words, this is a sequence of steps required for launching a product and supporting it.
Software development life cycle is a structured process that lies in the core of every software product development. Someone identifies a problem, discusses it with a group of like-minded or interested people, they come up with a solution, make drafts, invent something, find and fix bugs. Every step becomes an input to the next action. Altogether, they result in a new product delivered to a customer. Each step is a part of a certain phase.
Requirements. SDLC cycle starts from discussions. All the participants come together to share the thoughts on the final product. Their purpose is to determine the detailed requirements to a system, make sure every member understands their tasks, and prevent conflicts. QAs often get involved on this stage.
Prototyping, or design phase in software development, brings developers and system architects together. To design a multi-level system, they need to discuss technical issues that may arise and the ways to solve them. A team decides upon the technologies they are going to use, workflow, load, restrictions, budget, interaction with the third parties and databases, etc. Everything is properly documented.
Development. Back-end developers start coding. System admins setup the software environment. Front-end programmers develop user interfaces and the logic of interaction with a server. QAs can start unit tests at this early stage.
Testing. We look for the software defects: compare documented requirements with the actual features and search bugs. When a QA detects a defect, they create reports and transfer to developers. The latter fix the bug, then testing repeats. This time, a QA needs to make sure everything has been fixed and hasn’t affected other features. The testing goes on until all the requirements are met and no critical bugs left – a small internal software testing life cycle.
Implementation. When no more serious bugs are left, the time for the release comes. An implementation phase in SDLC is when a product becomes available for the audience.
Support. If any post-release bugs are detected, the team creates corresponding reports and handles the information to the development. Depending on the difficulty and urgency, some issues are fixed immediately (hot-fix), the others are released in the bext version.
Documentation is a conventional stage. Documents are created on all the stages of software life cycle – some describe development processes and fix procedures, some explain software specs and application. There are four main types of software development life cycle documentation:
Architecture (or project) – describes models, methodologies, tools, and means of development chosen for this particular project (for instance, design specifications).
Technical – a scope of the supporting files describing the work of the system on the level of separate modules; these are mostly comments to the source code that are later arranged in HTML documents.
User – guides and manuals, informational chapters, and things a user needs to figure out how the product works.
Marketing – promo materials that introduce a product to the wide user audience in an attractive way, showing all the competitive features and advantages.
It is necessary to understand that the stages of program life cycle don't exist separately. There are points of intersection that ensure the smooth transition to every next stage. All stakeholders participate during the entire SDLC with more or less involvement.
Some may wonder why the full software development life cycle is so important for testing and vice versa. That’s simple: testing is not an isolated process. It needs a product – a code or functionality – to check. It also needs requirements to set-up the check. Software development methodologies provide conventional schemes that join together the separate stages. Each stage requires different actions, but all are vital for the final result. It is like a piece of a puzzle in a big picture: one does not make sense without the rest.
It creates a full picture of the process – estimating, timing, scheduling, and budget.
It is a mechanism for project tracking and management.
It provides a specific framework for a standard set of activities.
It increases the development speed, decreases risks and delays.
It allows participation for all shareholders.
It establishes effective communication between the parties with defining inputs and output and the role of everyone in the process.
It improves client relations, both between internal and external customers.
It is impossible to develop a high-quality product without a plan. And any software development plan is better than no plan at all. In the end, how can you decide whether the product meets requirements if there are no requirements?
So how many stages to the software development life cycle exist? There are over a dozen approaches to SDLC nowadays. Different teams prefer to arrange a process according to their procedures, paying attention to documenting some stages more carefully than the others. The five-stage process, better known as the waterfall process, is currently one of the most popular.
#1. Requirements and analysis. Clients, managers, and stakeholders opening a brand new SDLC life cycle. They discuss a product, a course of development, and collect requirements.
#2. Design. A business analyst document the requirements. A designers prepare the background for further backend and frontend implementation. A QA specialist may start to create testing strategy for a product.
#3. Development. Developers divide their work into modules, units, etc., and start coding.
#4. Testing. This is when our team starts the main scope of work. The code is partially or fully developed by this time so we can begin the tests based on the documented requirements. This stahe features all the types of testing that can be apllied. We need to make sure the product meets client's expectations, is user-friendlyand bug-free.
#5. Maintenance. A company handles the product to a customer. Customers share problems that arise during software exploitation. QAs often detect some new issues on this stage. Sometimes, this stage of development lifecycle is rather passive for the development and QA teams.
There is one more popular approach, which features 7 stages of system development life cycle instead of the five described before. They come in the following order:
designing and prototyping;
and operation & maintenance.
Technically, it doesn’t differ much from the previous SDLC type, only some accents have shifted. For instance, planning and requirements are two separate stages, while the discussion of the initial idea is viewed outside SDLC in the waterfall process.
One more difference in the 7-stage system is deployment outlined into an independent stage. The previous approach suggests that some aspects should be included into the development stage, and some should relate to maintenance. If we speak about the one-time release, however, it would be logical to devote an entire stage to deployment.
It doesn’t matter how you decide to classify the stages, there is no such thing as the most important SDLC phase. Some of software development life cycle phases are long-lasting, some finish quite quickly, some get more attention. Can you miss one of those phases (do not confuse with “unite”) without affecting the entire process?
If you need a clearer SDLC example, let’s get back to the biological lifeforms. Think of SDLC as your daily routine with all the basic requirements: sleeping, eating, physical activity, socializing. You can miss something, and your organism will keep functioning, but it'll affect your heath – physical or psychological. In the case of the SDLC, we are talking about software health.
We hope everything is clear with phases. You may be wondering, what are those software development process models? Is this something different or another division into stages? Software development life cycle models are the ways those stages are arranged.
Remember our daily routine example? Some prefer jogging in the morning, some in the evening. There are people, work better after a walk, while the others find it difficult to concentrate in open space after 15 minutes outdoors.
The same thing with SDLC models. There is at least a dozen that are popular and frequently used. The choice depends on expectations and requirements to the final product, project specs and scale, and company policies.
The roots of the software development get back to the 1960s. Over 60 years of evolution with extremely rapid changes over the last two decades resulted in a wide variety of development strategies, methods, and of course software development life cycle models. We aren’t going to explain each of them, but here are some of the most used SDLC phases with examples of advantages and disadvantages.
The name “waterfall development life cycle” already explains a lot. SDLC waterfall means that phases come one after the other. To proceed to the next stage, you are to finish the current one. Every phase of a project takes place only once.
A strict order and a well-structured process with least surprises.
Opportunity to plan deadlines and resources accurately.
The requirements aren’t altered during the process.
A lack of flexibility and difficulties with too strict requirements
The testing starts only in the middle of the project.
Impossible to detect strong/weak sides and product value before the release.
Similarly to the waterfall model, it allows getting rid of the problems detected on the preceding stage. The processes on all stages are controlled to make sure that it is possible to move to the next level. The testing stars during writing the requirements.
The strict order of following the stages.
Better time management.
Minimum risks and opportunity to prevent major errors thanks to the testing on early stages.
Impossible to adapt to the continuously changing client’s requirements.
No actions are devoted to risk analysis.
Time-consuming development that sometimes lasts for years may end up in a situation, where a project is not relevant for the time/audience or not necessary for a client.
The software development process is linear. Every stage follows the previous one, but in several increments (versions). Product enhancement lasts in a planned order for as long as the product exists. System requirements are defined at the very beginning of the work. After that, the development process flows as a sequence of versions, where every next one is a finished and fully functioning product.
Clients can leave reviews about every version of the project.
Opportunity to predict risks related to expenses and stick to the schedule.
The adjustment to the new technology happens gradually.
The functional system should be fully outlined at the beginning in order to determine the iterations.
In the case of constant changes, system structure can be damaged.
Deadlines and release dates can be missed due to the limited resources (both executives and expenses).
Staring at the stage of planning, SDLC unfolds with every next step. After the exit of each next volution, we receive a tested prototype, which complements the current version. A prototype that gathers them all and meets the requirements is ready for the release.
Special attention is devoted to risk management.
Additional features can be added at the late stages.
There are enough opportunities for flexible designing and prototyping.
The risk estimation on every stage requires a lot of resources.
Continuous reviews and customer feedback trigger never-ending new iterations that significantly delay the release.
More applicable to large-scale projects.
The Agile development life cycle is a mix of various approaches. It is very dynamic and based on the constant interactions inside the self-managed working groups. These groups consist of the specialists of diverse profiles and deliver mini projects at the end of each iteration. One of the key ideas of Agile software development life cycle is interaction with a customer face to face.
Fast decision-making thanks to continuous communications.
Minimization of risks thanks to the instant reaction to problems and fixing them.
Easy documentation management.
A big number of talks and meetings can increase the time required for the release.
It is difficult to plan the process, because the requirements are constantly changing.
It is rarely used for the implementation of large-scale processes.
It all depends on a particular project and company. Regardless of system life cycle models applied, teams use some well-tried practices to reduce the risks and increase efficiency.
Source control helps to reduce the risks when it comes to coding and testing. A single server failure can ruin the achievements of an entire working day, while central repository saves the day.
Continuous integration keeps the software in the functional state. By assembling a program every time the code changes, you prevent errors and defects in the final version.
Management systems make complex projects easier to track. There is an entire class of software systems that assist in work management, bug tracking, even decision making.
The best way to choose which model fits best for your project is just to communicate with the dev and QA teams. Theycan explain SDLC models with real time examples, provide some insights, share experiences. It will be much more important than trying to figure it out by Googling the existing methods.
So you already know biological life cycle definition and the one used in IT, the basics of SDLC methodologies and phases. Sounds like it’s time for the SDLC phases with examples. To make it easier, let’s draw an analogy between the stages of software development life cycle and a school project.
You are informed about the upcoming school fair, where student will present their crafts and inventions. You decide to make a checklist to keep an easy track of the process and choose the 7-phase model.
#1. Planning. Think about possible options. What are you good at? What are other kids good at? What will help you to stand out? It is probably an awesome spacecraft model. You know about the space much more than any other kid. Your school lacks spacecraft models of proper quality. You will solve this problem.
#2. Requirement collection. You check out if other kids have presented similar projects. Then you find out what spacecraft models exist, what materials are available, how much time you have, when and where the fair takes place – as much details as possible.
#3. Designing and prototyping. You take a sheet of paper and draw your model. You make it using low-cost and easy-disposable materials – paper, matches, etc. You see the plan is going to work out and move to the serious work.
#4. Development. Time to make exactly the same model by using proper materials.
#5. Testing. You check whether all details are fixed and glued well, whether your spacecraft model looks the way it should. If it doesn’t, you need to spend some time on removing mistakes. If yes, well, congrats!
#6. Deployment. You have spent much on creating a beautiful but fragile model. Everything is ready, you just need to get safely into and out of parents’ car carrying it safely. And you check it once more before showing to a teacher and all other students.
#7. Operation and maintenance. Now, everyone is looking at your spacecraft. People ask questions, say it is awesome, some say it is ugly and unnecessary. Don’t worry, this is life and this is how it always happens. You keep an eye on your project till the very end of the fair. The spacecraft has completed its mission: you get a high grade! The lifecycle of your project ends.
We work with very diverse teams and projects, and each of them requires a specific approach. Agile works best for small companies and dynamic projects. A waterfall model is perfect for short-term projects, while an increment model is used most frequently for long-lasting products, where developers keep working on updates continuously.
To decide what approach to choose for a particular project, we discuss the working process with the team on your side. As a rule, we jump on a project when the development is in the height or is coming to an end. We pick up the tasks and ensure seamless integration, particularly, be using the SDLC you've already chosen.
It doesn't matter what SDLC you currently use. We'll be able to keep up. Contact us to discuss all the details.