Introduction
Most of us would think that to built a software, you just need effective coding skills and technology manipulation.
I spent years collecting programming languages like stamps, yet the actual creation of a working product remained impossible for me.
The secret isn’t int he code, it’s int he process. Professional Software is built through the Software Development Life Cycle (SDLC). It is a journey from a vague idea to a living tool.
SDLC consist of six different stages
- Planning
- Design and Architecture
- Development
- Testing
- Deployment
- Maintenance
In this post, I will walk you through each stages in SDLC. I will explain what is done in each stage and provide examples where applicable.
Planning
Requirements
Before a single line of code is written, we must ask
What are we actually building?
The planning phase is about gathering requirements. This includes
- Identifying stakeholders and relevant team members
- Defining goals and objectives
- Collecting requirements of the stakeholders through conducting surveys, questionnaires and interviews
- Documenting the requirements to ensure they are aligned with goals and objectives
- Reviewing and confirming the requirements with stakeholders for approval to ensure consistency, clarity and completeness.
- Prioritizing software features based on importance and feasibility
Software Development Methodologies
A Software Development Methodology is decided here. This is a process used to clarify communication and facilitate information sharing among team members. Some of the methodologies include
Waterfall
This is a sequential method where the output of the phase is an input to the next phase. Orderly but rigid.
V-Shaped Method
This is an adaption of waterfall method. V-shaped method consists of two different sides namely
- Verification Side
- Planning
- System Design
- Architect Design
- Module Design
- Coding
- Validation Side
- Unit Testing
- Integration Testing
- System Testing
- Acceptance Testing
The phase is sequential and as before. Clear but lacks flexibility.
Agile
The modern standard method. We work in short “sprints” that consists of a cycle of
- Plan Design
- Development
- Testing
- Deployment
- Feedback
The cycle is repeat until the software satisfies the requirements. With each cycle being quick, this allows flexibility for improvements.
The Agile development process consist of four core values
- Individual and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Response to change over following a plan.
While Agile development process has a lot of benefits, the downside to this method is that the budget is hard to identify because the scope of the product is not clearly defined.
Documentation
Once everything is complete, three documentations are created.
Software Requirements Specifications (SRS)
This document contains precise functional and non functional requirements. It acts as a formal agreement before the work begins
User Requirements Specification (URS)
This is like a user manual. Written in plain language, it describes what the user needs the software to do.
System Requirements Specification (SysRS)
This outlines the requirements of the systems, its technical details and its policies and the hardware limits
These three documents are usually crafted during the planning phase but it may be adjusted as the SDLC progress.
At this stage, a prototype is also created to help stakeholders verify project requirements. Prototypes are “product models” that help stakeholders gain a better understanding of what the software is about.
Design and Architecture
During the design phase, developers define the software architecture. It acts as a blueprint that guides how the system will be built. The architecture captures the major design decisions and defines how different parts of the system interact.
Software architecture consists of three main elements: components, nodes, and architectural patterns.
Components
Components are the building blocks of a system. Each component performs a specific function within the overall architecture.
Common components include:
- modules are unit of code that provide specific function or a set of functions. They can be developed, tested and maintained independently. Good modules should be
- cohesive or grouped together with related functions.
- loosely coupled or weakly associated with other modules so that their change impact is minimal.
- services are functional units that performed specific tasks through an interface. Like modules, they are loosely coupled so they can operate independently
- connectors enable communication between components. They allow different parts of the system to exchange data and coordinate actions.
Nodes
Nodes are devices on a network that can recognize, process and transmit data. Multiple nodes connect together to form a distributed system.
Nodes provide an infrastructures for components to run and communicate across the network.
Architectural Patterns
Architectural Patterns define how the system is structured and how its components interact.
Common architectural patterns include:
Peer to Peer
- Peer to peer is a system where all nodes are connected together. Each node can act as a client and a server, sharing resources directly with other nodes.
Microservices
- Microservices is a system where loosely coupled services communicate using API gateway
Event Driven
- Event Driven is a system that focuses on interactions between producer and consumer.
Client Server Architecture
- Client Server divides the system into clients, which requesting services, and servers, which provide them.
Model View Controller
- Model View Controller separates the system into three connected layers namely
- The Presentation Layer (The User Interface)
- The Application Layer (The Business Logic)
- The Data Layer (The Database)
Development
During the development phase, developers build the software using various programming tools and technologies. These tools help manage code, speed up development, and organize the application structure.
Some common development tools include the following.
Version Control System
Version control systems track changes made to the codebase over time.
Tools such as GitHub allow developers to see what changes were made, who made them, and when they were introduced. This makes collaboration easier and helps teams manage software updates.
Libraries
ibraries are collections of reusable code that simplify development. Instead of writing common functions from scratch, developers can reuse existing libraries.
Libraries are often included within a framework.
Frameworks
A framework is a development platform that provides built-in tools, libraries, and structure for building applications. It helps developers follow standardized practices and speeds up development.
Examples include Django, React, and Spring.
Software Stacks
A software stack is a group of technologies used together to build and run an application.
For example, a web application stack may include:
- a programming language
- a database
- a web server
- a frontend framework
One common example is the LAMP stack (Linux, Apache, MySQL, PHP).
Programming Languages
Programming languages are used to instruct computers how to perform tasks.
They can be broadly categorized into two types.
Interpreted Languages
Interpreted languages use an interpreter to translate code into machine instructions at runtime. The program is executed line by line.
Compiled Languages
Compiled languages use a compiler to translate the entire program into machine code before execution. The compiler generates an executable file that can run directly on the computer.
Testing
During the testing phase, developers verify that the software functions correctly functioned and meet the required specifications. Testing helps identify bugs, ensure reliability and confirm that the software meets stakeholder expectations.
Testing can be categorized into several types
Testing Types
Functional Testing
Functional testing verifies whether the software satisfies stakeholder requirements and performs its intended functions correctly.
Non-Functional Testing
Non-functional testing evaluates system qualities such as:
- performance
- security
- scalability
- reliability
These tests ensure the software operates efficiently under different conditions.
Regression Testing
Regression testing ensures that new changes or updates do not break existing functionality. It confirms that previously working features still operate correctly after modifications.
Testing Levels
Software testing is usually performed across four different levels
Unit Testing
Unit testing focuses on individual components or small sections of code. Each unit is tested separately to ensure that it behaves as expected.
Integration Testing
Integration testing verifies that multiple components work together correctly when combined in a larger system. Like unit testing, this also happens during the development phase.
System Testing
System testing evaluates the entire application as a complete system. The goal is to confirm that the software satisfies the requirements defined in the Software Requirement Specifications (SRS).
Acceptance Testing
Acceptance testing verifies that the software meets business needs and is ready for deployment. This testing is typically performed near the deployment phase of the SDLC.
The best practice is to follow the testing pyramid where:
- Unit tests are emphasized – fast and inexpensive
- Fewer integration tests – slower and more complex
- Very few system or acceptance tests – even slower and more complicated
Deployment
During the deployment phase, the software is released for use by users. Deployment usually occurs in several stages to ensure stability before a full public release.
Firstly, the alpha version is release to selected stakeholders to check for bugs and requirements testing.
The goal of alpha testing is to identify major bugs and verify that the core function works correctly. Changes may be implemented at this time.
Then, the beta version is release to all stakeholders to test the software under real conditions, testing for other functionalities, performance issues, and remaining bugs before its final release.
Finally, the General Audience (GA) version is release to the public. It is made available to the public for full use.
Maintenance
After deployment, the software enters the maintenance phase. During this stage, developers monitor the system for bugs reported by users and identify opportunities for improvements or new features.
If issues are discovered, developers fix the problems and release software updates.
To keep track of updates, each release is assigned a version number. Versioning helps developers and users identify changes between software releases.
Continuous Integration with Continuous Delivery and Continuous Deployment (CI/CD)
Throughout the SDLC, CI/CD pipelines is usually implemented to automate development and release process.
CI/CD is a practice of continuous integration with continuous delivery and deployment that automates building, testing, and deploying a software. It is implement through a build automation server. An example of an automation servers are Git Hub Actions, Jenkins, Azure DevOps
CI (Continuous Integration) automatically builds and tests your code, ensuring that the code components work together smoothly. This is done in the development phase.
CD (Continuous Delivery) automatically tests your entire software ensuring that it is ready to be deployed. This stage requires manual approval.
CD (Continuous Deployment) automatically launches the software into a production environment if the code passes the test. This is done during deployment and testing phase.
Once the code is release to general audience, If the error was found, fixes are made and run through CI/CD again.
Conclusion
Having learn the software development lifecycle, I realize that development of a software takes a lot of work.
The software development lifecycle provides the framework that transform an abstract idea into a working product. Each phase plays a distinct role.
Without its structure, software projects become chaotic. Code may exist, but the product doesn’t work as intended.
Understanding SDLC reveals an important lesson
Successful softwares are engineered through a discipline process.
Learning this process is just as important as learning programming languages. Code may be power to software, but this lifecycle makes creating a software possible.
Disclosures
AI tools were used to assist with outlining, clarification, and editing suggestions.
All ideas, interpretations, and final writing decisions are my own.
Leave a Reply