Software Intern at Qualcomm

During my 11-week internship at Qualcomm, I was tasked with solving critical bottlenecks in the system-level debugging workflow. The project involved creating a high-performance memory analysis ecosystem that transitioned the team from manual log parsing to an automated, cloud-native visualization platform.

Goal: To develop a tool that displays the difference between the 'before' and 'after' versions of all files in a particular build.

Motivation: Given the massive scale of Qualcomm's builds, developers needed to introspect where changes occurred without manual log analysis. Unlike standard tools that only show raw code differences, this tool provides a high-level abstraction of functional containers (functions, structures, unions) to surface the true impact of a changelist.

Implementation:

• Built a Python-based engine to fetch .c and .h files for specific changelists using Araxis Merge.
• Integrated Source Insight to extract structural metadata.
• Developed an algorithm to compare file versions and keep track of LOC for functions, structures, and unions.
• Served the results via a Flask application, providing a real-time summary of changes.

Key Tools: Python, Flask, Source Insight, Araxis Merge.

Goal: To develop a centralized platform to analyze and visualize the memory requirements of a build, shifting from local scripts to a scalable cloud architecture.

Motivation: Identifying memory bottlenecks in complex builds was previously a fragmented process involving local script execution. This platform centralizes and automates memory analysis, providing team-wide visibility into memory hierarchy and regressions that were difficult to track across distributed build environments.

Technical Stack & Architecture:

• Frontend: Developed using ReactJS with Material UI for a modern, responsive UI.
• Backend: Built with Node.js and Express to handle high-concurrency requests.
• Database: Used MongoDB for flexible storage of hierarchical module/sub-module data.
• Deployment: Containerized using Docker and orchestrated via Kubernetes for load balancing and high availability.

Key Improvements:

• Visual Dashboards: Graphical visualization for modules and sub-modules using D3.js/Chart.js patterns.
• Automated Workflow: Deployed as a downstream job on Jenkins, triggered automatically upon build completion.
• User Authentication: Integrated secure login for internal access control.
• Smart Notifications: Automated email delivery of memory reports, including direct links to the web analysis page.

Key Tools: ReactJS, Node.js, Express, MongoDB, Jenkins, Docker, Kubernetes.

The system achieved immediate team-wide adoption, fundamentally changing how memory regressions are tracked.

• 85% Reduction in manual memory analysis time.
• 75% Storage Optimization for build metadata.
• Team-wide Adoption: Impacted the engineering workflow by surfacing bottlenecks early in the development cycle.
• Full-Time Offer: The project's success and its direct impact on developer productivity contributed to a full-time return offer.