Introduction

This blog post marks the final milestone of my journey through the Anveshan Track. What started as a series of individual technical tasks gradually became a holistic learning experience, one that strengthened not only my technical skills, but also my approach to problem-solving, design thinking, and self-discipline.

Each task pushed me to step slightly outside my comfort zone, explore unfamiliar tools, and reflect on my progress. This README serves as a reflection on that journey: the lessons learned, challenges faced, and growth achieved along the way.

Task 00 — Codeforces (Not Completed)

The program began with a strong emphasis on competitive programming through Codeforces. While I understood the importance of consistent practice and algorithmic thinking, I was unable to actively complete this task during the program timeline.

That said, this task highlighted an important takeaway for me:

Growth in problem-solving requires patience, consistency, and long-term commitment—not just short bursts of effort.

It reminded me that competitive programming is a skill I need to revisit with a more structured and disciplined approach in the future.

Task 01 — Git Fundamentals

This task laid the foundation for everything that followed.

By solving challenges from gitexercises.fracz.com, I moved beyond memorizing commands and began to truly think in Git. Concepts like commits, branching, rebasing, stashing, and history rewriting became clearer through hands-on problem-solving.

What I Gained

This task reshaped how I view code management and teamwork.

Task 02 — Software Requirements Specification (SRS)

Creating the SRS for MeloFi was my first step into structured software planning.

Instead of jumping straight into coding, I learned the importance of defining:

Writing the SRS helped me realize that good software begins with clarity, not code. It trained me to think like a product designer as much as a developer.

Task 03 — Wireframing

Wireframing introduced me to visual thinking.

By designing low-fidelity wireframes for both web and mobile versions of MeloFi, I focused on layout, navigation flow, and user interaction—without worrying about aesthetics.

Key Learning

This task taught me to design with intent, not assumptions.

Task 04 — UI Design

This was where ideas came alive.

Converting wireframes into high-fidelity UI designs using Figma allowed me to explore spacing, icons, components, and visual consistency. Designing both mobile and desktop versions helped me understand responsiveness and adaptability.

This task was especially rewarding because it blended creativity with logic, two skills that rarely meet but work best together.

Task 05 — Frontend Development

Building the frontend of MeloFi using React was one of the most challenging yet satisfying tasks.

What I Achieved

What I Couldn’t Complete

This task taught me an important lesson:

It’s okay to not finish everything—as long as you understand why and learn from it.

Debugging UI issues, managing state, and connecting APIs significantly improved my frontend confidence.

Task 06 — Backend Development

Backend development with Flask pushed me into a more logic-driven mindset.

I implemented:

While I couldn’t complete playlist and profile APIs, this task gave me clarity on backend architecture and security fundamentals.

It transformed backend development from something intimidating into something approachable.

Task 07 — Mobile App Development

This task focused on building the Android frontend for the MeloFi music streaming app using Kotlin and Jetpack Compose.

What I Built

Tools Used

What I Couldn’t Complete

This task helped me understand the basics of Android app development, API integration, and building reusable UI components with Jetpack Compose.

Task 08 — Build a Simple Shell

This task stood out as one of the most technically enriching experiences.

Building a Unix shell in C helped me understand what happens beneath the abstractions we often take for granted. Implementing process creation, job control, background execution, and signal handling deepened my understanding of operating systems.

Even though I couldn’t fully implement Ctrl+C and Ctrl+Z handling, I learned how real shells work—and gained respect for their complexity.

Key Takeaways From the Journey

Advice for Future Participants

Conclusion

This track was more than a checklist of tasks—it was a journey of growth, discipline, and self-discovery. Each task added a layer to my understanding of software development, from idea to implementation.

This is not the end, just a strong beginning.