Project Overview

"Hold My VM" was designed to streamline the debugging process for software developers by addressing challenges during automated test passes. When errors occur, replicating the exact environment can be time-consuming and unreliable.

My solution: provide an in-place method for users to debug failures without recreating conditions from scratch — while also reducing manual work for infrastructure teams.

Objectives and Goals

Allow Multi-Machine Reservation

Multi-machine reservations were previously a tedious, multi-step process. My goal was to make reserving multiple VMs as seamless as reserving a single machine.

Allow Reservation from Focus Web

By connecting Focus Web directly to the reservation APIs, users no longer needed to switch between platforms or manually collect VM details to reserve machines.

Add Usage Controls

Added settings for time limits and checkout limits to optimize VM usage and prevent resource bottlenecks.

Challenges and Roadblocks

Results

I successfully automated the multi-machine reservation process, making it faster, easier, and less error-prone for developers. The system now allows seamless reservation through Focus Web with minimal manual steps.

Next Steps

The project was handed off for future scaling and possible extensions to support even more complex debugging workflows.

Role Overview:

As Engineering Chair for Hack4Impact at Cornell, I was responsible for building and sustaining the technical backbone of the organization. My role involved onboarding and supporting technical leads (TLs) and developers on the team, making sure everyone was following excellent coding practices, and leading technical workshops. Beyond the technical aspects, I also worked to create a collaborative, and supportive environment where team members could grow not just as engineers, but as individuals.

Objectives and Goals

New Members Recruitment and Onboarding

Recruitment was a fun challenge every semester that involved hosting information sessions, coffee chats, designing the technical interview, leading these interviews, and evaluating the candidates while making sure that the selected candidates will contribute to Hack4Impact’s mission of creating technology for good by always putting sustainability, empathy, and diversity at the forefront.

​​Since we primarily recruited freshmen and sophomores, I made it a priority to evaluate each applicant not just by their current technical ability, but by their potential to grow. I focused on what each individual could become by focusing on their eagerness to learn, their mindset, and how we as a team could support their development, rather than what they already knew.

To reflect this in our process, I designed a technical interview that assessed a range of relevant skills developers would use on their subteams instead of the traditional Leedcode style questions that only tests current skills. Our interviews tested abilities to write clean, and testable code; refactoring poorly written code; demonstrating adaptability through challenges like changing and adding functionalities to existing classes, and systems design questions that tested their way of thinking and reasoning about development.

This approach allowed us to welcome developers from less technically rigorous backgrounds, many of whom went on to excel. It also reinforced one of Hack4Impact’s core values: building a diverse and inclusive team where people from all backgrounds feel empowered to contribute and grow.

I was also in charge of onboarding the new developers that joined the team. I created and led an interactive onboarding curriculum for new developers, featuring a two-hour hands-on workshop on Git fundamentals, agile development methodologies, and best engineering practices. I also organized an onboarding Hackathon to put the fundamentals they learned in the first workshop into use. The developer had to use a project starter repository cloned from Git to develop a simple website similar to ones they would soon start working on their subteams, giving new developers sprint-style tasks in a collaborative environment.

Technical Leadership Development

My co-engineering chair, Jason, and I designed and led onboarding workshops for the Technical Leads, covering full project lifecycle management from early planning through deployment and client handoff. We outlined best practices in system design, emphasizing scalability and flexibility to the clients’ changing needs, and maintainability through the early creation of System Design Documents (SDDs). Additionally, we established engineering standards across projects, including: Enforced GitHub workflows: branch naming conventions, mandatory pull request (PR) reviews, sprint planning using GitHub Projects, and CI/CD setup templates. Introduced agile development practices: how to assign weekly sprint cycles, backlog grooming, regular stand-ups, and cross-functional team communication. Fostered high code quality standards: pair programming, peer reviews, thorough documentation, and post-development sustainability planning for client handoff.

Career Development

I hosted technical interview prep workshops open to both Hack4Impact members and the larger Cornell student body. These sessions covered both behavioral and technical interview skills, including:

• Algorithms practice (e.g., LeetCode patterns)
• System design exercises
• Effective communication strategies during interviews

Additionally, I led a hands-on workshop designed to demystify personal projects and help students gain the confidence and tools to start building their own ideas outside the classroom.

Workshop Goals & Structure

• Broke down what personal projects are and why they matter, emphasizing exploration, skill-building, and resume development over perfection or polish.
• Provided a broad range of project types to inspire attendees—from lightweight HTML/CSS websites and GitHub-hosted portfolios to more advanced ideas like ML/AI applications, API audits, and game development.
• Emphasized that personal projects can be driven by curiosity, creativity, or real-world problems, helping students see themselves as capable builders, regardless of background.

Key Topics Covered

• Types of projects: personal websites, AI/ML experiments, auditing APIs, beginner and large-scale software builds.
• Getting started: strategies for scoping projects, reusing class work, and building incrementally.
• Real-world impact: discussed algorithmic fairness and tech accountability using case studies like ProPublica’s COMPAS investigation.
• Resource sharing: curated tutorials, GitHub idea banks, and intro guides to open-source contribution (e.g., Google Summer of Code).

Impact

• Lowered the barrier to entry for students hesitant about starting projects due to lack of experience or confidence.
• Empowered participants to see personal projects as a low-pressure, high-value way to learn new skills and discover interests.
• Helped students generate concrete ideas during the live ideation session, with many leaving with the outline of a project they were excited to pursue.
• Reinforced Hack4Impact’s commitment to technical growth, inclusion, and practical impact by creating an accessible on-ramp to building and experimentation.

Challenges and Roadblocks

Result & Key Takeaways

Being an engineering chair for a year taught me that leadership isn't about control, but about building trust, offering empathy, and creating opportunities for others to grow. It requires constant learning, emotional intelligence, and the ability to stay flexible under changing circumstances. Some of the most meaningful moments came from seeing developers build confidence, overcome challenges, and step into leadership roles themselves.

Course Description:

This interdisciplinary course explores how network structures influence behavior and outcomes across computing, economics, sociology, and natural systems. Students learn graph theory and game theory, then apply these tools to analyze the Web, market behavior, contagion, search, and network evolution. Topics include social network analysis, market power in networks, strategic interaction, web search algorithms, information diffusion, network cascades, and institutional design. Core course for the Information Science major.

Key Tools & Concepts:

Graph theory, game theory, strategic behavior, web search, market design, network diffusion, social contagion, equilibrium analysis, and network centrality.

Role Overview and Responsibilities:

• Held weekly office hours to support students in mastering the course material and solving problem sets through one-on-one and group-based problem-solving sessions.
• Led comprehensive review workshops prior to midterm and final exams, helping students consolidate material and confirm their understanding by walking through exam-style problems.
• Provided continuous support via Ed Discussions by answering student questions with clear, structured written explanations.
• Ensured accurate, fair, and integrity-compliant grading for all assignments and exams.
• Created an inclusive and efficient learning environment even under high demand, particularly when office hours coincided with homework deadlines.

Challenges:

• High Demand Before Deadlines: My office hours were often held a few hours before weekly homework deadlines, and were frequently attended by 20+ students at a time. To manage this volume fairly, I implemented a strict queue system and adapted the format by grouping students with similar questions to conduct collaborative problem-solving sessions. This improved efficiency while maintaining individual support.
• Reputation of Difficulty: As this is a core and notoriously math-intensive course for the Information Science major, many students found the material intimidating. I focused on breaking down difficult concepts using intuitive examples and real-world analogies to make the material more approachable.
• High Standards for Grading: Given the mathematical rigor of the course and the emphasis on academic integrity, I approached grading with extreme care, ensuring consistent application of partial credit and rubrics, and maintaining full confidentiality of student grades.

Results:

I was invited to return as a TA for a second term, indicating strong teaching performance and rapport with both students and instructors. It was really rewarding to see how I was able to help students improve understanding in a challenging course and watch them grow as students and people throughout the semesters. All the stress and work was worth it when a student who regularly came to my office hours came up to me on campus and said that I was the best TA in the class :)

Our Partner: Environmental Data Governance Initiative (EDGI)

EDGI is an action-oriented research collaborative that works at the intersection of environmental justice, data transparency, and public accountability. Their mission is to:

• Investigate how federal agencies like the EPA neglect vulnerable communities
• Monitor and document changes in environmental data and governance practices
• Use data science to advocate for stronger environmental protections
• Empower communities to safeguard public health and ecosystems

Project Overview:

The EDGI team at Hack4Impact Cornell partnered with the organization to transform static and complex environmental data into a public-facing, interactive platform. Our goal was to build an accessible and user-friendly site to explore regional report cards and environmental enforcement data.

Objectives and Goals

Develop an interactive visualization platform

• Clickable maps for U.S. states and counties
• Dynamic sidebars showing localized environmental report cards
• Built using the Streamlit framework for lightweight, responsive visualizations

Enable data exploration and insights

• Recreate and enhance analysis from Jupyter notebooks in a live frontend
• Allow users to view enforcement trends, violations, and compliance patterns by regions

My Contributions:

As one of seven developers on this project, I focused on translating technical analysis into intuitive visual tools:

• Migrated backend analysis to the frontend: Reconstructed data workflows from Jupyter notebooks into live, interactive Streamlit components, making dry datasets more accessible and engaging.
• Improved search and filtering capabilities: Built out search selectors that let users explore trends by state and county, while ensuring accurate syncing with the map visualizations.

• Integrated user input with maps: Connected selectbox filters to the Folium-based interactive map, enabling users to zoom into specific regions and explore data visually.
• Styled the user interface: Attempted to align the platform with design mockups by customizing Streamlit components using CSS, despite Streamlit’s styling limitations.

Tools and Technologies:

• Streamlit (Python): Enabled the display of interactive maps, graphs, and selectors in a streamlined frontend experience.
• Folium & GeoJSON: Used to power the region-specific map and zoom interactions.
• SQLite: Served as the local database for environmental data.
• CSS: Used for interface customization to match the design system, despite Streamlit’s relatively limited styling support.

Challenges:

• Streamlit, while efficient for simple dashboards, proved difficult to style and scale for more advanced design interactions.
• Customizing the search component and integrating it with the map zoom functionality involved significant workaround and troubleshooting.
• Dependency management and converting notebook-based workflows into modular backend logic required collaboration and careful planning.

Even though there were many challenges and a steap learning curve, I was able to finish my assigned deliverables, resulting in this application:

Reflections:

This project emphasized the importance of building tools that bridge technical insight with public understanding. We transformed isolated data analysis into a platform that communities and policymakers can interact with directly—an essential step in making environmental justice actionable and transparent. It was challenging in many ways, and I wanted to thank my co-developer Selena for collaborating through every step—from debugging dependency issues to turning design wireframes into real-world, functioning tools.

Role Overview

As a Teaching Assistant for CS 4820: Introduction to Analysis of Algorithms in Spring 2024, I supported a core upper-level computer science course known for its theoretical rigor and broad enrollment. The course covered essential algorithmic design paradigms—including greedy algorithms, divide and conquer, dynamic programming, and network flow—as well as complexity theory and approximation techniques. I worked closely with both instructors and students, serving as a key point of contact for clarifying course material, assisting with assignments, and facilitating exam preparation.

Objectives and Goals

• Provide regular support for students to master complex algorithmic concepts and problem-solving techniques.
• Promote a deeper understanding of course material through one-on-one and group-based learning strategies.
• Ensure fair, accurate, and confidential grading of homework and exams in alignment with Cornell’s academic integrity policies.
• Foster a collaborative learning environment, both in-person and online, to help students navigate one of the department’s most demanding courses.

Challenges

• High Course Difficulty: CS 4820 is a required course for all CS majors and is widely regarded as one of the most challenging in the curriculum. This meant facing complex problems that often required revisiting and mastering advanced concepts myself before I could confidently explain or grade them.
• Scalability of Support: With a large student body, it was challenging to provide individualized attention. I had to balance live office hours, online discussion board support, and exam prep workshops while maintaining consistency and fairness in grading.
• Conceptual Depth: The course's emphasis on formal proof techniques and computational intractability posed unique pedagogical challenges that required more than superficial explanation—I had to guide students in building a deeper intuition.

Results, Impact, and Achievements

• Held 3 weekly office hours, during which I assisted students in understanding algorithm design strategies, analyzing time complexity, and constructing formal proofs—often by drawing connections to similar solved problems.
• Led exam review workshops before each prelim and the final exam, attended by dozens of students, to consolidate key topics, clarify doubts, and work through practice problems collaboratively.
• Provided asynchronous support by answering student questions on Ed Discussions, often with detailed step-by-step written solutions to ensure clarity and reproducibility.
• Graded homework and exams with a commitment to fairness, consistency, and confidentiality, ensuring that feedback aligned with rubrics and academic standards.
• Developed technical and teaching skills by independently solving difficult problems prior to helping students, ultimately strengthening my own understanding of advanced algorithms.

Our Partner: Lagos Food Bank Initiative (LFBI)

Lagos Food Bank is a nutrition-focused nonprofit in Nigeria dedicated to combating hunger, reducing food waste, and improving public health through targeted community programs. Volunteers are at the heart of their operations, supporting events that provide essential services across the region.

Lagos Food Bank relies on volunteers for nearly every initiative. However, managing this growing volunteer network had become increasingly time-consuming. Hours were tracked manually through paper sign-in sheets, and staff had to comb through records to verify service hours before issuing certificates or reference letters.

To address these challenges, Lagos Food Bank partnered with Hack4Impact Cornell to design a centralized platform that would simplify volunteer hour tracking, speed up event check-ins, and improve the volunteer experience across the board.

Project Overview:

This semester, I worked on the Lagos Food Bank subteam at Hack4Impact Cornell. Our mission was to design a streamlined volunteer management system tailored to the nonprofit’s operations. The platform needed to serve three user types—volunteers, supervisors, and administrators—each with different goals and pain points.

I focused on designing key workflows that improved how users interact with upcoming events and manage organizational data. By reducing administrative burden and modernizing check-in and certificate processes, our tool helps the nonprofit scale its impact and better support the communities it serves.

User research:

Through multiple partner interviews, we identified several pain points in the current system:

• Scattered RSVP processes: Volunteers were asked to RSVP through a mix of Instagram DMs, WhatsApp reactions, and Google Forms—leading to confusion and missed sign-ups.
• Inefficient tracking: Event attendance was logged through Google Form exports or even paper-based check-ins, making tracking slow, error-prone, and manual.
• No centralized hour tracking: Volunteers lacked a reliable way to track their own hours, often leaving them uncertain about when they could request service certificates.
• Administrative burden: Staff were required to manually confirm volunteer hours for community service documentation, increasing their workload.

In response, we proposed a centralized platform that simplifies volunteer signups, streamlines event attendance tracking, and automates hour logging—all while providing role-specific interfaces for different users.

Design Process & Iterations:

We began by mapping out the information architecture and user flows for all three user types. Centralizing sign-up flows without disrupting existing workflows was a significant challenge, and required close collaboration with our nonprofit partners. After extensive feedback, we arrived at streamlined, intuitive flows for:

• Volunteers: Sign up, browse upcoming events, track hours, and request certificates.
• Supervisors: Create and manage events, track attendance, and update volunteer participation records.
• Admins: Edit system metadata and oversee platform-wide functionality

To deepen our understanding, we developed a volunteer journey map. This visual aid helped us pinpoint friction at each stage of the volunteer lifecycle and guided brainstorming for user-centered design solutions. After many partner calls we ended up with the following changes:

After we finalized the user flow we also made a journey map for the volunteers. This helped us reiterate what problems arose at each step of volunteering for LFBI. This really helped us with visualizing the problems, and helped us brainstorm on how we might solve these issues.

Design Execution:

Browse Events Page

My first design task was the "Browse Events" page for all user roles. I focused on how users could intuitively search, filter, and view events.

Design decisions: I tested various card layouts and sorting mechanisms. Ultimately, I chose medium-sized cards without images—logos and stock photos didn’t add value and only created visual noise.

Edit Metadata Page

Next, I tackled the admin-only metadata page. It was important to make this page clearly restricted from volunteer or supervisor access, while keeping it simple and efficient for admin use.

I experimented with layouts including sidebars, but eventually opted for a minimal vertical structure. Since the page’s content was relatively short, eliminating the sidebar simplified development and avoided unnecessary complexity. My final design looked like this: