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.