Hey, I’m Maraviz! Thank you for your interest in my first blog! In this article, we’ll explore the software development life cycle (SDLC) and explore how CI/CD pipelines can streamline traditional processes to enable faster, more reliable software delivery.
In today’s fast-paced digital world, software development relies on a structured approach to deliver reliable and high-quality products. One such approach is the Software Development Life Cycle (SDLC)—a step-by-step framework that guides software development from inception to maintenance.
With the rise of CI/CD (continuous integration/continuous deployment) pipelines, SDLCs have become more automated and agile, allowing teams to deliver updates quickly while maintaining high standards. In this blog, we’ll explore the SDLC, its stages, and how modern CI/CD pipelines can improve its efficiency.
What is SDLC?
SDLC means that it is a structured framework for designing, developing, testing and deploying software applications. It covers the entire process from software creation to deployment in a production environment.
Okay, so what are the needs of the SDLC?
For examplea company plans to launch a new e-commerce website that will allow customers to browse products, make purchases, and track orders. The company wants to ensure that the website is user-friendly, secure, and performs well during peak traffic times. Now companies must follow the SDLC process to create applications and send them to production. Let’s see how SDLC performs in the given example.
First, let’s discuss what are the stages of SDLC and how we can build an e-commerce application in the stages of SDLC.
To meet the requirements of a production environment, the SDLC consists of several stages, they are:
-
planning — Target: Define project goals, scope, and resources.
Example – Discuss scope of how the website should look, required functionality (product catalog, shopping cart and payment gateway), discuss target launch date. -
Needs Analysis – Goals: Understand what the software must do and gather functional and non-functional requirements.
example — Ensure stakeholders’ business needs are clearly understood, such as enabling easy browsing, checkout systems and efficient order tracking.
- Design – Goals: Build software using workflows, modules, and database architecture
example — Help plan the structure of the website. The development team will design the website’s UI and define how the application interacts with the database to store user data, product details, and transaction records.
- Development (Implementation) – Objectives:Write and integrate code based on design documents.
example — Development teams write code to build website features such as product catalogs, shopping carts, and checkout systems. Then use version control to track the application and check that the code is updated regularly to ensure progress.
Note: Why use version control for tracking because it allows developers to track code changes over a period of time.
- Test – Goal: Identify and fix errors through features and performance
example — Conduct thorough testing to ensure the site works as expected. Tests such as unit testing to ensure that individual features are functioning; integration testing to verify that the entire application works together as expected; and performance testing to ensure that the website can handle a large number of users during peak traffic periods.
- Deployment – Target: Launch the software in a production environment.
example — Here, the company will use some deployment tools to push the application into production and make it publicly accessible.
- Maintenance – Goals: Provide updates, fix bugs and ensure long-term performance.
example — Once the website is live, the development team monitors its performance and resolves any issues that arise, such as bug fixes or regular updates.
Hopefully we’ve covered the various stages of SDLC with the best examples, let’s see how you can use CI/CD pipelines to automate the SDLC stages in modern development.
CI/CD process in SDLC:
What processes does CI/CD include in SDLC? — Build, test, package, deploy
These processes are related to the SDLC stages — Build (development phase), Test (testing phase), Package (testing phase), Deploy (deployment phase)
Let’s discuss what developers would do before CI/CD to meet business needs and deliver on time. Before the advent of CI/CD pipeline automation technology, developers mostly relied on manuals, which were slow and error-prone.
Here is an overview: Code is written manually; testing is done manually or with limited automation tools; after testing is complete, the application is manually packaged into a deployable format (for example, a JAR or WAR file); deployment involves manually copying the file to the server server or execute a custom script. Overall, this is very time consuming for developers.
Transitioning to CI/CD:
CI/CD replaces these manual processes with automated pipelines, enabling faster builds, automated testing, seamless deployment, and rapid feedback loops. Let’s check what it does 🙂
Continuous Integration (CI):
- Automatically integrate code changes into a shared repository.
- Example: Developer pushes code to GitHub repository, Jenkins gets triggers/updates and automatically builds and tests the application.
Continuous deployment (CD):
- Ensure software is always ready for deployment.
- example: Artifacts such as Docker containers are stored in repositories such as JFrog Artifactory, ready for staging or production.
Let’s not get confused, we’re going to break this down now. We discussed what processes are required for a CI/CD pipeline workflow to complete the SDLC process. In this process, organizations may follow two different approaches. Let’s break it down.
Method one:
This process is handled entirely in Jenkins, which builds, tests, packages and deploys the software:
Until phase 3, the process will be the same and starting from SDLC phase 4, the following CI/CD workflow will take place. Let’s explore it.
put up – When Jenkins receives an update/trigger from a repository (e.g. GitHub, GitLab, Bitbucket), it fetches the latest code, builds and compiles it using that code, and resolves any dependencies.
test – Jenkins executes automated tests—including unit tests and integration tests—to verify that the code functions correctly.
pack – After the test is successful, Jenkins packages the code into a deployable build artifact. The build artifact can be an executable file (for example, a JAR file, WAR file, ZIP file, or docker image)
deploy– Jenkins automatically pushes software to CD tools such as Ansible, Kubernetes, or other deployment tools for staging and production environments.
Key points: This process compiles and packages code directly into deployable artifacts and then sends them for deployment without intermediate steps. It’s best suited for smaller applications or environments that don’t require artifacts to be stored in a centralized repository for reuse or review. Since there is no artifact repository (such as JFrog Artifactory or Docker Hub) in this workflow, the artifacts are moved directly from Jenkins to the deployment tool.
Method two:
put up – When Jenkins receives a trigger to update code from a repository (such as GitHub, GitLab, Bitbucket), it fetches the latest code, builds and compiles it, and resolves dependencies.
test – Jenkins performs automated testing, including unit testing and integration testing, to ensure that the code works as expected.
pack –
- Jenkins packages applications into build artifacts, such as JAR files, WAR files, or Docker images.
- Use the Jenkins Artifactory plugin to push packaged artifacts to artifact repositories (e.g. JFrog Artifactory, AWS, Azure, GCP).
notes: Here Jenkins doesn’t know where the artifact repository is placed. However, jenkins has plugins that integrate into CI/CD pipelines.
- For other containerizations: Jenkins retrieves artifacts from the artifact repository.
- Build a Docker image using a Dockerfile that defines the container environment.
- The Docker image is transferred back to the artifact repository for: Storage for later use.
- After completing the above process and security checks, the developer retrieves the build artifact from the repository for deployment.
Key points: This process includes using artifact repositories such as JFrog Artifactory, Docker Hub, AWS, GCP, Azure, etc. to centrally store and distribute build artifacts. This is common in large applications or containerized environments where multiple teams need access to the same artifacts and need to store the artifacts for auditing, compliance, or reusability. Using an artifact repository provides better version control, traceability, and scalability.
deploy– After the above process, Jenkins triggers the deployment job, passing the artifacts to the CD tool (such as Ansible for server provisioning or Kubernetes for container orchestration). In other words, the CI tool (Jenkins) shares artifacts with the CD tool (Ansible or Kubernetes) for production deployment.
Finally, after the deployment phase, it will be continuously monitored.
Maintenance –
Provide updates, fix bugs and ensure long-term performance.
Example: Regularly patch vulnerabilities and release new features based on user feedback.
Real-life example: Jenkins and Ansible for e-commerce websites
Let’s see how Jenkins and Ansible work together when deploying an e-commerce website with new payment gateway functionality:
Code integration:
- Developers push code updates to the GitHub repository.
- Jenkins automatically fetches the code and executes unit tests to verify payment gateway functionality.
- Build and artifact storage:
- Jenkins builds a Docker image of the website and stores it in a secure repository such as Docker Hub or JFrog Artifactory.
- deploy:
- Kubernetes pulls Docker images, deploys them to production, and manages automatic scaling during periods of high traffic.
This automated pipeline accelerates delivery while maintaining quality standards, minimizing human error, and achieving business goals.
notes: CI and CD tools vary based on project needs. Few CI and CD tools are listed for later 🙂
_Other CI tools: Jenkins, GitLab CI, Travis CI, Circle CI, TeamCity, Azure DevOps, and more.
Other CD tools: Bamboo, Ansible, Argo CD, Spinnaker, Harness, Buildkit_
in conclusion:
SDLC forms the backbone of structured software development, and modern CI/CD pipelines enhance it with speed, automation, and reliability. This powerful combination enables teams to quickly deliver high-quality applications that meet user expectations and business needs.
Let me know what you think about SDLC and CI/CD? Share your experiences or questions in the comments below!
In the next blog, we will discuss How to integrate security into SDLC, turning it into Secure SDLC (SSDL) Ensure robust and secure software development. stay tuned!