# Journey from Traditional Software Development to DevOps and Agile Practices

When we started working on our very first software project, We followed a **traditional Software Development Life Cycle (SDLC)** approach. It was linear, structured, and often called the *Waterfall model*. Each phase—requirement gathering, design, development, testing, and deployment—was done in sequence.

At that time, it felt straightforward. But as projects grew bigger and more dynamic, I noticed a few challenges:

* Any small change in requirements was difficult to manage.
    
* Feedback often came late, usually after the product was nearly finished.
    
* Collaboration between developers, testers, and operations was minimal.
    
* Delivery cycles were slow, making it harder to respond to fast-changing user needs.
    

This is where I began exploring **modern approaches to SDLC**—focusing on **Agile methodologies, Scrum frameworks, Jira as a project management tool, and DevOps practices.**

## **From Traditional SDLC to Agile and DevOps**

Unlike the traditional model, **Agile** emphasizes adaptability, customer collaboration, and incremental delivery. Instead of waiting months for a final product, Agile teams deliver working software in short iterations, often called *sprints*.

This approach made me realize that:

* Software should be delivered in **small, valuable increments**.
    
* **Continuous feedback** ensures we build the right thing.
    
* Teams should work **collaboratively across development, testing, and operations**.
    

And when Agile meets automation and cloud practices, that’s where **DevOps** comes into the picture.

## **What is Agile and Why is it Important?**

**Agile** is a mindset and methodology that focuses on delivering value to the customer quickly and effectively. Instead of rigid documentation and long delivery timelines, Agile promotes:

* **Iterative development** (small releases)
    
* **Continuous feedback** from stakeholders
    
* **Flexibility** to adapt to changes
    
* **Cross-functional collaboration**
    

Agile is important because modern software projects demand **speed + quality**. Customers expect rapid updates, bug fixes, and new features—Agile enables teams to meet those expectations without burning out.

## **What is Scrum?**

Within Agile, **Scrum** is one of the most popular frameworks. It organizes work into **sprints** (usually 1–2 weeks long), with clearly defined roles and ceremonies.

* **Roles**: Product Owner, Scrum Master, and Development Team
    
* **Ceremonies**: Sprint Planning, Daily Standups, Sprint Review, Sprint Retrospective
    
* **Artifacts**: Product Backlog, Sprint Backlog, and Increment
    

Scrum helps keep teams **focused**, ensures **transparency** of progress, and fosters a cycle of **continuous improvement**.

## **What is Jira and How Do We Use It?**

When I started applying Agile in my projects, I used **Jira**, a popular project management tool by Atlassian.

Jira allows teams to:

* Create **Epics, Stories, and Tasks** to structure work.
    
* Plan and run **sprints** with defined goals.
    
* Use **Kanban or Scrum boards** to visualize progress.
    
* Track metrics like **burndown charts** for transparency.
    

In my own practice projects, I created Epics like *“Improve UI discoverability & trust”* and then broke them down into stories such as *“Hero tagline clarity”* or *“Primary CTA color.”* Using Jira made the entire sprint cycle feel organized and measurable.

## **How I Used Jira in My Projects**

For managing my Agile sprints, I used **Jira**, which is a powerful tool for planning, tracking, and delivering software efficiently. Here’s a simple way beginners can get started:

**Step 1: Create a Project**

* Choose **Software → Scrum → Team-managed**.
    
* Give it a name (e.g., *Gotto Job – Solo Pujan*).
    

**Step 2: Add Epics & Stories**

* Create **Epics** for big goals (e.g., *Improve UI discoverability*).
    
* Add **Stories** under Epics with clear titles, descriptions, and acceptance criteria.
    
* Estimate each story with **story points** (1, 2, 3…).
    

**Step 3: Plan a Sprint**

* Drag 3–4 stories into a sprint.
    
* Set a **Sprint Goal** (e.g., *Ship 2–3 visible UI improvements*).
    

**Step 4: Subtasks & Progress Tracking**

* Break stories into subtasks: **Build → Verify → Deploy → Screenshot**.
    
* Move tasks across the board as you work: *To Do → In Progress → Done*.
    

**Step 5: Review & Retro**

* Demo the increment.
    
* Write **Retro notes**: What went well, what to improve, Scrum pillar observed, Scrum value practiced.
    
* Check **burndown chart** for sprint progress.
    

Using Jira helped me **organize my work, visualize progress, and deliver small increments** efficiently in my recent projects like *Gotto Job* and *Mini Finance footer deployment on EC2*.

## **The DevOps Life Cycle**

While Agile focuses on *how we manage work*, **DevOps** focuses on *how we build and deliver software efficiently*.

The **DevOps Life Cycle** is usually represented as an infinity loop, covering continuous phases:

1. **Plan** – Define requirements and track progress (Agile + Jira).
    
2. **Code** – Write clean, maintainable code (Git, GitHub, VS Code).
    
3. **Build** – Compile and package the software (CI pipelines).
    
4. **Test** – Automate testing for quality assurance.
    
5. **Release** – Deploy software to staging/production.
    
6. **Deploy** – Push updates using tools like Docker, Kubernetes, or AWS EC2.
    
7. **Operate** – Monitor system performance and uptime.
    
8. **Monitor** – Collect feedback and performance metrics to start the cycle again.
    

This cycle emphasizes **automation, collaboration, and continuous delivery**, ensuring faster and more reliable deployments.

## **What I Did in My Present Projects**

In my recent practice projects, I combined **Agile, Jira, and DevOps** concepts to simulate real-world workflows:

* Used **Jira Scrum boards** to create Epics and Stories.
    
* Planned and executed **mini-sprints** with goals like *“Deploy footer with version and date on EC2.”*
    
* Broke down tasks into **subtasks** (Build, Verify, Deploy, Screenshot).
    
* Deployed my project on **AWS EC2** with Nginx as the web server.
    
* Practiced retrospectives by reflecting on **what went well, what could improve, and Scrum values observed.**
    

This hands-on approach gave me clarity on how modern teams actually build, ship, and improve software continuously.

## **Final Thoughts**

Looking back, moving from **traditional SDLC** to **Agile + DevOps practices** has been a huge leap in our learning journey. Agile brought adaptability, Scrum gave structure, Jira made work visible, and DevOps ensured smooth delivery.

Even in small practice projects, applying these frameworks has helped us think like a **real-world engineer**, preparing us for bigger roles in Cloud, DevOps, and Agile teams.