DEV Community: Khushi Shah

Beyond the First Commit: My Journey to Rank 48 at ECSoC’26

Khushi Shah — Fri, 30 Oct 2026 12:05:39 +0000

From discovering open source to contributing 117 merged pull requests across 16 projects — a journey shaped by curiosity, collaboration, continuous learning, and consistency.

Khushi Shah

B.Tech Computer Science and Engineering at PW IOI

Professional Profiles

GitHub: shahkhushi0307
LinkedIn: Khushi Shah
Instagram: @_khushishah_03

ECSoC’26 Resources

Introduction

Open-source development offers something that traditional academic learning often cannot fully replicate: the opportunity to work on real-world software, collaborate with distributed developer communities, understand existing codebases, and contribute to projects used by others.

My journey into this ecosystem began with curiosity and limited practical experience. I had an interest in software development, but I was still learning how collaborative development worked beyond individual projects and academic assignments.

Participating in Elite Coder Summer of Code 2026 (ECSoC’26) became an important turning point in that journey.

By the conclusion of the program on August 31, 2026, I had achieved 48th rank among approximately 13,000 participants and 822 active contributors, with 117 merged pull requests across 16 open-source projects
These achievements represent months of technical exploration, problem-solving, code reviews, collaboration, and consistent effort.

However, the most meaningful part of this experience was not the final ranking. It was the transformation from someone unfamiliar with open-source contribution workflows into an active contributor capable of navigating multiple repositories and collaborating with project maintainers.

This is the story behind that transformation.

01. The Foundation: My First Industry Experience

I am a B.Tech Computer Science and Engineering student at PW IOI. My initial exposure to collaborative software development came through my first internship at PW LeapX as a Frontend Developer Intern.

The internship introduced me to practical development workflows and provided an opportunity to work in a team environment.

Alongside frontend development, I gained experience with:

Git and GitHub for version control and collaborative development.
Working with team members on shared development tasks.
Understanding project requirements and implementation workflows.
Building and improving frontend interfaces.
Participating in a structured software development environment.

This experience gave me a foundation for understanding how software is developed collaboratively.

As I became more comfortable with GitHub, I started exploring public repositories and learning about open-source communities.

I was particularly interested in the opportunity to contribute to existing software, learn from experienced developers, and understand how large projects evolve through community collaboration.

At that stage, I was looking forward to participating in GSSoC. I had the motivation to contribute, but I still needed practical exposure to the open-source contribution process.

02. Discovering ECSoC’26: Taking the First Step

My introduction to ECSoC’26 came through a friend who suggested that I register for Elite Coder Summer of Code 2026.

Initially, I was uncertain about participating.

Although I had some development experience, I lacked a clear understanding of how open-source programs operated in practice. I was unfamiliar with repository selection, issue assignment, maintainer communication, contribution guidelines, and the pull request review process.

I was interested in participating, but I questioned whether I had sufficient experience.

A friend's encouragement helped me overcome that hesitation. Instead of waiting until I felt completely prepared, I decided to register and learn through the experience.

That decision marked the beginning of my ECSoC’26 journey.

The registration itself was straightforward. Understanding how to make meaningful contributions was the real challenge.

I needed to learn how to identify suitable projects, understand their technical requirements, navigate unfamiliar codebases, and submit changes that met the expectations of maintainers.

03. Building Technical Understanding Through PW IOI

An important part of my preparation came through an initiative introduced by PW IOI to encourage students to explore open-source development.

Through this initiative, I received guidance from Abhinav Awasthi Sir and Akash Meruva Sir.

Their mentorship helped me understand the practical aspects of contributing to open-source projects, including:

Exploring repositories and understanding their architecture.
Reading documentation and contribution guidelines.
Identifying issues suitable for contribution.
Understanding GitHub workflows and pull request procedures.
Communicating effectively with project maintainers.
Incorporating review feedback and improving implementations.

This guidance helped me connect my existing development knowledge with the actual practices followed by open-source communities.

I began approaching repositories more systematically, studying their structure, understanding the technologies they used, and identifying issues where I could make meaningful contributions.

I am sincerely grateful to both mentors for their guidance and for helping me develop the confidence to begin contributing.

04. The First Merged Pull Request

The transition from learning about open source to making an actual contribution was an important milestone.

After exploring several repositories, I identified an issue that aligned with my technical understanding and expressed my interest in working on it.

Once the issue was assigned, I began examining the relevant code, understanding the existing implementation, and identifying the changes required to address the problem.

Like most first-time contributors, I had several concerns.

Would my implementation satisfy the acceptance criteria? Had I understood the issue correctly? Would the maintainer approve the changes?

Nevertheless, I completed the implementation and submitted my first pull request.

The pull request was merged the following day.

That first successful merge was a defining moment for me.

It provided practical validation that I could contribute to an existing project, understand its requirements, and deliver changes that met the maintainer's expectations.

More importantly, it changed how I viewed open-source development.

I realised that contributing to an established project requires much more than writing code. It involves understanding context, respecting existing architecture, following development standards, communicating clearly, and responding constructively to feedback.

My first merged pull request gave me the confidence to explore more repositories and take on increasingly challenging contributions.

05. Expanding My Contributions Across Projects

Following my first successful contribution, I decided to remain actively involved throughout ECSoC’26.

During July and August, I consistently explored new repositories, analysed open issues, worked on implementations, and submitted pull requests.

Contributing across multiple projects exposed me to different codebases, development practices, technologies, and engineering approaches.

Each repository presented a different learning opportunity.

Some contributions required understanding unfamiliar project structures. Others involved debugging existing implementations, analysing requirements, or modifying code while maintaining compatibility with established functionality.

The review process also became an important part of my learning.

Maintainers frequently provided suggestions, requested refinements, or highlighted areas where implementations could be improved. Incorporating this feedback helped me develop a stronger understanding of code quality, maintainability, and collaborative engineering.

Balancing contributions with academic responsibilities was another significant challenge.

There were periods when managing college assignments and development work simultaneously required careful planning and discipline.

Rather than focusing only on the number of contributions, I gradually developed a more consistent approach to learning and problem-solving.

During this period, I also maintained a 35-day GitHub contribution streak, reflecting my commitment to making continuous progress.

06. ECSoC’26: Achievements and Milestones

By August 31, 2026, my participation in ECSoC’26 had resulted in several milestones that I am proud to share.

Key achievements

Achievement	Result
ECSoC’26 Global Rank	48
Merged Pull Requests	117
Open-Source Projects	16
GitHub Contribution Streak	35 days
Total Program Participants	Approximately 13,000
Active Contributors	822

Securing 48th rank was a significant achievement, but the numbers alone do not capture the complete experience.

Each merged pull request represented an opportunity to understand a problem, analyse an existing implementation, develop a solution, and collaborate with maintainers.

Contributing to 16 different projects strengthened my ability to adapt to unfamiliar codebases and work across different development environments.

The experience also helped me become more independent in identifying problems, researching solutions, and implementing changes.

Most importantly, it reinforced my understanding that technical growth comes through consistent practical engagement.

07. Recognition by PW IOI

One of the most memorable highlights of this journey was having our ECSoC’26 achievement featured on the official PW IOI Instagram platform.

Being recognised by the institution's official platform was a meaningful moment, particularly because PW IOI had also played an important role in providing the learning environment and guidance that helped me begin my open-source journey.

The recognition made the achievement even more special and highlighted the importance of encouraging students to participate in practical learning opportunities beyond the classroom.

I am grateful to PW IOI for supporting initiatives that expose students to real-world development practices, technical communities, and opportunities for professional growth.

Official recognition:

View the ECSoC’26 Feature on PW IOI's Official Instagram

Visit the Official PW IOI Website

08. Technical and Professional Learnings

Beyond the final ranking and contribution statistics, ECSoC’26 helped me develop several skills that will remain valuable throughout my software engineering journey.

Working with existing codebases

I developed greater confidence in navigating unfamiliar repositories, understanding existing architecture, identifying dependencies, and making changes within established project structures.

Version control and collaborative workflows

Regular contributions strengthened my understanding of Git, GitHub, branches, commits, pull requests, and collaborative development practices.

Code quality and maintainability

Working with maintainers and responding to reviews helped me understand the importance of writing clean, readable, maintainable code that follows project conventions.

Technical problem-solving

Different issues required different approaches to debugging, research, implementation, and testing. This improved my ability to approach unfamiliar technical problems systematically.

Communication and collaboration

Interacting with maintainers helped me understand how to communicate technical decisions, clarify requirements, discuss implementation approaches, and respond professionally to feedback.

Discipline and time management

Maintaining regular contributions alongside academic responsibilities strengthened my ability to manage time and work consistently toward long-term goals.

These experiences have helped me develop a more practical understanding of software engineering and collaborative development.

09. Advice for Students Beginning Their Open-Source Journey

For students who are interested in open source but are unsure about where to begin, my biggest recommendation is to start with what you already know and build from there.

You do not need to master every technology or understand every aspect of software engineering before making your first contribution.

Start by becoming comfortable with Git and GitHub. Explore repositories that interest you, read their documentation, understand their contribution guidelines, and identify issues that match your current skill level.

Do not hesitate to ask maintainers for clarification when necessary.

Your first contribution may require several attempts. Your pull request might receive review comments, and your implementation may need modifications before it is accepted.

These are normal parts of collaborative software development.

Instead of viewing feedback as rejection, treat it as an opportunity to improve your technical understanding.

Most importantly, focus on learning rather than comparing your progress with someone else's achievements.

You do not have to be an expert to contribute to open source. You have to be willing to learn, collaborate, and improve with every contribution.

10. Acknowledgements

This journey has been shaped by the support, encouragement, and guidance of several individuals and communities.

I would like to express my sincere gratitude to:

My friend, whose encouragement motivated me to register for ECSoC’26 when I was initially hesitant.
PW LeapX, for providing my first internship experience and introducing me to collaborative software development.
PW IOI, for creating valuable learning opportunities and encouraging students to participate in open-source initiatives.
Abhinav Awasthi Sir and Akash Meruva Sir, for their mentorship, guidance, and support in helping me understand the open-source contribution process.
Open-source maintainers and developer communities, for reviewing my contributions, sharing constructive feedback, and providing an environment for continuous learning.

I am thankful to everyone who contributed to this experience and helped make it a memorable milestone in my journey.

Looking Forward

ECSoC’26 has been an important milestone in my development journey, but I consider it a foundation for what comes next.

The experience has strengthened my interest in open-source software development and encouraged me to continue contributing to meaningful projects, exploring new technologies, and collaborating with developers across different communities.

From being uncertain about my first contribution to achieving 48th rank, this journey has reinforced an important lesson: progress begins when we are willing to step beyond our comfort zone and learn through experience.

117 merged pull requests. 16 open-source projects. A 35-day contribution streak. One transformative learning experience.

These milestones represent not only what I accomplished during ECSoC’26, but also the skills, confidence, and perspective I gained along the way.

I look forward to building on this experience, taking on new challenges, and contributing to the open-source ecosystem in the future.

The journey continues.

Connect With Me

I welcome opportunities to connect with developers, open-source contributors, technology enthusiasts, and communities working on meaningful projects.

GitHub: github.com/shahkhushi0307
LinkedIn: Khushi Shah
Instagram: @_khushishah_03

ECSoC’26 Achievement Resources

Learning to Building: My Journey as a Full Stack Developer Intern at PW LeapX

Khushi Shah — Fri, 30 Oct 2026 11:34:27 +0000

·
Reflections on my Full Stack Developer internship at PW LeapX, working on ClassForge, exploring modern web technologies, and learning real-world software engineering practices.

By Khushi Shah· BTech at Computer Science Student at PW IOI Pune

There is a significant difference between learning software development and experiencing how software is actually built.

As students, much of our early development journey revolves around programming languages, technical concepts, coding assignments, tutorials, and personal projects. We learn how to write code, solve problems, and build functional interfaces. However, understanding how these individual skills come together to create a real-world product requires an entirely different perspective.

Questions such as How does an idea become a working product? How do development teams collaborate? What goes into building scalable applications? were things I wanted to understand beyond the classroom.

My journey as a Full Stack Developer Intern at PW LeapX gave me the opportunity to explore these questions firsthand.

What began as an opportunity to apply my technical knowledge gradually evolved into a meaningful learning experience, helping me understand the practical aspects of software development, teamwork, product thinking, and engineering practices.

Here is a reflection on my experience so far.

1. The Transition from Learning to Practical Development

Understanding programming concepts and implementing them in real-world applications are two different experiences.

While academic assignments generally come with well-defined requirements and expected outputs, real-world development involves understanding the problem before deciding on the solution.

It requires considering multiple aspects, including:

Understanding functional and technical requirements.
Designing maintainable application architectures.
Building intuitive and responsive user interfaces.
Managing application data and state.
Integrating frontend components with backend services.
Ensuring consistency across different modules.

I wanted to experience this complete development process rather than limit my learning to individual technologies or isolated projects.

Joining PW LeapX provided an opportunity to take that step.

2. Getting Started at PW LeapX

Getting selected as a Full Stack Developer Intern at PW LeapX was an important milestone in my development journey.

It introduced me to a collaborative engineering environment where understanding the project, exploring existing implementations, and coordinating with team members were just as important as writing code.

One of my earliest realizations was that software development does not begin with opening a code editor.

It begins with understanding the problem.

Before implementing a feature, developers need to understand its purpose, existing application structure, dependencies, and expected behaviour. Reading requirements, exploring the codebase, discussing implementation approaches, and breaking down tasks are essential parts of the process.

This experience also helped me appreciate the importance of communication and collaboration when multiple developers contribute to the same product.

3. Working on ClassForge: A Multi-Tenant School Management Platform

One of the major projects I have been contributing to at PW LeapX is ClassForge, a multi-tenant School Management System designed to bring various academic and administrative operations together on a unified platform.

The platform aims to provide dedicated experiences for different user roles, including school administrators, teachers, and students.

What makes ClassForge particularly interesting is the coordination required between different modules, permissions, user roles, and application workflows.

My contributions and learning have involved several areas of the application:

Authentication and Login Experience

Working on the login interface and understanding how frontend authentication flows connect with backend authentication services and user information.

Dashboard Development

Contributing to structured dashboard interfaces that present relevant information and help users navigate different sections of the application.

School Management and Settings

Working on school workspace experiences and settings interfaces for managing school-related configurations and administrative information.

Frontend Development

Translating design requirements into functional interfaces using reusable components, maintaining consistent layouts, and ensuring responsive behaviour across screen sizes.

Frontend-Backend Integration

Understanding how frontend components communicate with backend APIs, how application data flows between different layers, and how authentication and database operations contribute to the overall system.

Working on ClassForge has reinforced an important engineering principle: building a product is not simply about creating individual screens. It is about making sure every component and module works together as part of a consistent, reliable application.

4. Technologies and Engineering Concepts

Working on ClassForge has given me the opportunity to explore how different technologies work together within a modern web application.

Some of the technologies I have been working with and strengthening my understanding of include:

React

Developing a better understanding of component-based architecture, reusable UI elements, state management, and building interactive user interfaces.

Next.js

Exploring application routing, modern rendering capabilities, and structuring frontend and backend functionality within a unified application framework.

TypeScript

Understanding the importance of static typing, predictable data structures, and maintainability when working with larger codebases.

PostgreSQL

Strengthening my understanding of relational databases, data modelling, relationships, and how application data is stored and retrieved.

Beyond learning these technologies individually, the most valuable part has been understanding how they interact.

For example, a user interaction on the frontend may trigger an API request, which communicates with the backend, performs the required database operation, and returns a response that the interface needs to handle appropriately.

Understanding this complete flow has helped me develop a broader perspective on full-stack development.

5. Understanding Existing Codebases and Team Workflows

One of the most valuable lessons from this experience has been realizing that software development involves much more than writing new code.

A significant part of working on an existing product is understanding the code that is already there.

When contributing to an established codebase, it is important to understand its folder structure, component relationships, existing implementation patterns, dependencies, and architectural decisions before making changes.

Sometimes, a seemingly small feature requires understanding multiple interconnected modules.

This has helped me appreciate the importance of:

Writing clean and readable code.
Building reusable and maintainable components.
Following consistent naming conventions.
Understanding existing implementation patterns.
Using Git and GitHub effectively.
Communicating changes and collaborating with teammates.

These practices are not merely technical preferences. They form the foundation of effective software engineering, particularly when working on products developed by multiple contributors.

6. Developing a Product-Oriented Approach to UI/UX

Coming from an interest in frontend development, one of the interesting aspects of this internship has been learning to look beyond the visual appearance of an interface.

A good user interface is not defined only by colours, typography, spacing, or visual elements.

It is defined by how effectively users can interact with the application.

While working on different interfaces, I have started considering questions such as:

Is the navigation intuitive?
Is information presented in a logical structure?
Are similar components consistent throughout the application?
How does the interface behave when data is unavailable?
Is the experience responsive across different devices?
Does the interface communicate loading, success, and error states clearly?

These considerations have helped me understand the practical relationship between UI design, user experience, and frontend engineering.

The goal is not simply to build an interface that looks good, but to create one that is understandable, accessible, and functional.

7. Key Lessons and Takeaways

Looking back at my experience so far, a few lessons stand out.

1. Understand the Requirement Before Writing Code

A clear understanding of the problem and existing architecture helps prevent unnecessary rework and leads to better implementation decisions.

2. Write Code for Maintainability, Not Just Functionality

Code should be understandable, reusable, and easy for other developers to work with.

3. Communication Is an Essential Engineering Skill

Discussing implementation approaches, asking questions, sharing progress, and communicating blockers are important parts of collaborative development.

4. Understand the Complete Application Flow

Knowing how the frontend, backend, APIs, authentication, and databases interact provides a much stronger understanding of how modern applications work.

5. Treat Challenges as Learning Opportunities

Unfamiliar code, unexpected bugs, and new concepts are inevitable. Approaching them with curiosity and patience is essential for continuous improvement.

8. Beyond the Internship: A Shift in Perspective

The biggest outcome of this experience is not simply the number of technologies I have explored or the features I have contributed to.

It is the change in how I approach software development.

Earlier, my primary focus was often on completing a coding task or implementing a particular feature.

Now, I find myself thinking about broader engineering questions:

Why is this feature needed? How does it fit into the existing architecture? How will users interact with it? What happens when something goes wrong? Can the implementation be maintained and extended in the future?

This shift from task-oriented development to product-oriented thinking is something I consider one of the most valuable outcomes of my internship.

I am grateful to PW LeapX for providing me with this opportunity, to my mentors for their guidance, and to my teammates for creating an environment where collaboration and continuous learning are encouraged.

Every implementation, discussion, challenge, and bug has contributed something valuable to my learning journey.

9. A Message to Aspiring Developers

For students who are learning software development and waiting for the right opportunity to work on real-world applications, I would like to share one simple thought:

Do not wait until you know everything to start building.

Work on projects. Explore unfamiliar technologies. Learn Git and GitHub. Read existing codebases. Collaborate with other developers. Most importantly, understand the reasoning behind the code you write.

You do not need to have all the answers before taking your first step. What matters is your willingness to learn, experiment, accept feedback, and improve consistently.

I am still learning, exploring new technologies, and discovering better ways to approach engineering challenges. However, this experience at PW LeapX has given me a much clearer understanding of what it means to contribute to a real-world software product.

From understanding concepts in the classroom to applying them in a collaborative development environment, this journey has been an important step in my growth as a developer.

And this is only the beginning. 🚀

Let's Connect and Grow Together

I believe that continuous learning, collaboration, and sharing experiences play an important role in becoming a better developer.

I'm always excited to connect with fellow developers, explore new technologies, exchange ideas, and learn from the experiences of others.

If you're interested in technology, software development, or building meaningful products, feel free to connect with me:

GitHub: shahkhushi0307
LinkedIn: Khushi Shah
Instagram: @_khushishah_03

Thank you for taking the time to read about my journey at PW LeapX.

I'm looking forward to continuing this journey of learning, building, contributing, and growing as a developer.

Every opportunity to learn is an opportunity to build something better.

This is just the beginning!