Aaryan Singh
Software Engineering Intern
C#
C++
SQL
C
Node JS
JavaScript
TypeScript
Python
Active 1 day ago
+1 (224) 8755013
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Frontend app engineer (middle) focused on building React and React Native user-facing apps with integration to backend services and data visualizations. The strongest proven skill is building async data flows and simple client-side caching as shown by a DrugInfo service that reads/writes Firestore and a reusable useFetch hook. There is limited evidence of advanced state machines, comprehensive testing, cancellation-aware hooks, or measured performance optimization.
Technical skills
C#
C++
SQL
C
Node JS• Middle
JavaScript• Middle
TypeScript• Middle
Python• Middle
C++
TensorFlow C++
Node JS
Axios
Dotenv
Python
PyQt
FastAPI
Pydantic
Requests
Uvicorn
SQLAlchemy
Databases
Firestore
Frontend
Tailwind CSS
React.js
PostCSS
D3.js
Bootstrap
React Bootstrap
ESLint
React Router
DevOps
Rest API
Mobile
Firebase
Expo
React Native
AI/ML
Copilot
LangChain
LangGraph
NumPy
Streamlit
Scikit-learn
Statsmodels
TensorFlow
Analytics
Matplotlib
Cybersecurity
Scapy
Wireshark
Timeline
Board of Directors
•
Executive
Xperience Consulting
•
Part-Time
Led coding camps and technical programs for students while coordinating projects and assigning tasks across team members, contributing to the growth of the organization into a nationally recognized non-profit
Secured funding and worked with leadership to manage projects and grow educational programs
React.js
Java
Head of App Dev & Software Engineering Intern
•
Executive
FiPet
•
Internship
Developed and shipped mobile frontend features using React Native, improving usability and user experience. Worked with the startup team to integrate Firebase-backed data into the UI. Took on a technical leadership role by preparing architecture documentation, performing code reviews, and coordinating tasks to speed up delivery.
React Native
Firebase
MediTrack
Mobile app
Developed a cross-platform mobile app with React Native, TypeScript, and Expo, designing a clean interface for users to search, save, and manage medications
Integrated AI into the app using a multi-step LangGraph pipeline to analyze user medication lists and identify drug interactions, side effects, and safety warnings
Built a Python FastAPI backend that connects external drug databases with Firebase Firestore to retrieve medication safety data
React Native
Expo
Firebase
LangGraph
Python
TypeScript
FastAPI
University of Illinois at Urbana-Champaign
Bachelor's Degree •
Computer Science (Minor in Data Science)
Built Python data pipelines using pandas to clean, transform, and organize raw game data into player performance datasets
Developed lineup-level metrics including plus-minus and offensive/defensive efficiency to help the coaching staff evaluate player combinations and team performance
Python
Pandas
Matplotlib
Developed a React frontend and Python FastAPI backend to analyze NBA data and train TensorFlow models to predict NBA champions
React.js
Python
TensorFlow
Pandas
Recharts
Code Sensei
•
Middle
Code Ninjas
Taught programming and game development to students, emphasizing problem-solving, debugging, and core programming concepts.
Javasince 2021
C#
JavaScript
Python
Software Engineering Intern
•
Junior
Tachyon Dynamics
•
Internship
Built a network testing framework using Scapy and Wireshark to validate IPv6 connectivity. Created automated test suites to detect performance bottlenecks and help resolve network issues. Ensured testing results supported compliance with Federal IPv6 requirements.
Scapy
Wireshark
Middle Backend Developer
Confidence: Medium API Engineer
A pragmatic middle-level backend API engineer who builds integrations between web APIs, external data sources, and LLM-based agents - strongest at implementing end-to-end feature flows that combine data ingestion and simple orchestration. The most proven skill is building an LLM-driven agent and tool invocation loop as implemented in MediTrack/backend/ai/agent.py and MediTrack/backend/ai/model.py that ties a generative model to a single-tool search integration. Limited evidence exists for production-grade concerns such as authentication/authorization, structured observability, migrations, retries/timeouts, and scalable deployment patterns.
API Design
3/10
How well APIs are designed
API design is functional with clear FastAPI endpoints and basic input validation, but lacks versioning, idempotency keys, pagination, and a consistent error contract across services.
Evidence
HoopsNet/backend/app/main.py: get_nba_stats - Query param validation and error JSON for invalid stat
MediTrack/services/drugInfo.ts: calls to http://127.0.0.1:8000/llm-drug-info and error handling around fetch
Data Layer & Database
3/10
Working with databases
Data handling shows practical use of Firestore and pandas-based ETL and cleaning, but there is no migration history, explicit transaction handling, or hand-tuned SQL/index work.
Evidence
MediTrack/services/drugInfo.ts: getDoc/setDoc usage interacting with Firestore
HoopsNet/frontend/src/prediction/model/data.py: CSV extraction and feature assembly using pandas
MediTrack/backend/services/openfda.py: parsing OpenFDA JSON and extracting fields
Scalability & Performance
2/10
Handling load and speed
Some pragmatic limits and filtering are present, but there is little evidence of caching strategies, background queue decoupling, rate limiting, or measured performance optimizations.
Evidence
HoopsNet/backend/app/main.py: uses df.nlargest(8, 'value') to limit results returned
MediTrack/services/medCalc.ts: deterministic in-memory scheduling logic (computeNextDose/findNextMedication) showing basic algorithmic consideration
System Architecture
3/10
Overall system structure
Code is organized into logical modules (AI agent, external services, frontend), and the LangGraph agent shows deliberate design, but there is minimal evidence of config/secret management beyond dotenv or of service decomposition decisions for production-grade microservices.
Evidence
MediTrack/backend/ai/agent.py: StateGraph-based agent orchestration with node/edge setup
Project layout: separation between MediTrack backend services (openfda, ai agent) and frontend service callers (services/drugInfo.ts)
Security & Auth
2/10
Protecting data and access
Basic security hygiene is present (dotenv for keys, limited input validation), but authentication/authorization, secret lifecycle, and stronger input boundary protections are not implemented.
Evidence
MediTrack/backend/services/openfda.py: load_dotenv and explicit check for API key presence
HoopsNet/backend/app/main.py: get_nba_stats validates 'stat' against a fixed STAT_OPTIONS set
Reliability & Observability
2/10
Stability and monitoring
There is minimal reliability and observability work: some try/catch and response.raise_for_status use, but no timeouts with backoff, structured logging, metrics, or graceful shutdown patterns.
Evidence
MediTrack/backend/services/openfda.py: response.raise_for_status() after requests.get
MediTrack/services/drugInfo.ts: try/catch around network calls with console.error logging
MediTrack/backend/ai/agent.py: debug prints in take_action (no structured logging or retry/backoff)
Expertise
Backend AI & LLM• Middle
Microservices & API Architecture• Middle
Python• Middle
Industries
Health Care• Middle
Sports• Middle
Technologies
Node JS• Middle
Rest API
FastAPI
Pydantic
Axios
Dotenv
Recommendations
- Develop LLM-augmented backend features that integrate external authorities (OpenFDA, DailyMed) where the agent graph pattern is needed.
- Implement and harden REST APIs and backend glue for mobile apps, including auth, timeouts, retry with backoff, and structured logging.
- Build sports-analytics data pipelines and model-serving endpoints that reuse the existing pandas/TensorFlow work and add batching, caching, and deployment considerations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
Frontend app engineer (middle) focused on building React and React Native user-facing apps with integration to backend services and data visualizations. The strongest proven skill is building async data flows and simple client-side caching as shown by a DrugInfo service that reads/writes Firestore and a reusable useFetch hook. There is limited evidence of advanced state machines, comprehensive testing, cancellation-aware hooks, or measured performance optimization.
UI Component Architecture
3/10
How interface parts are built
Component composition is pragmatic using react-bootstrap and small custom components; there is a custom hook but no evidence of a homegrown design system or deliberate component-system decisions.
Evidence
21st-century-F1/src/home/index.js: Carousel and composition using react-bootstrap components
21st-century-F1/src/results/Results-Search.js: Results table component and row composition
MediTrack/services/useFetch.ts: custom useFetch hook implementing async data fetching lifecycle
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive layout relies on Bootstrap grid and responsive images; no evidence of advanced fluid typographic strategies, container queries, RTL support or progressive enhancement beyond basic responsiveness.
Evidence
21st-century-F1/src/home/index.js: use of react-bootstrap Container and responsive Carousel
21st-century-F1/src/results/index.js: Container, responsive Image and bootstrap grid usage
Performance Optimization
2/10
Speed of the interface
Little to no measured performance work or code-splitting; a naive attempt at request cancellation exists but is incomplete and there is no evidence of virtualization or bundle analysis.
Evidence
21st-century-F1/src/results/Results-Search.js: creates AbortController but does not pass signal to fetch (ineffective cancellation)
MediTrack/services/useFetch.ts: basic fetch lifecycle with no cancellation or memoized caching
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility signals such as visually-hidden spinner text and proper semantic tags in places, but no focused a11y work for custom widgets, ARIA, keyboard management or CI a11y checks.
Evidence
21st-century-F1/src/results/Results-Search.js: Spinner includes visually-hidden text
21st-century-F1/src/home/index.js: NavLink usage with role attributes
State Management & Data Flow
3/10
Managing data in the app
Uses standard React state and effects, a reusable useFetch hook, and Firestore caching for fetched drug info; lacks advanced server-state discipline like cancellation integrated into hooks, optimistic updates or explicit cache invalidation strategies.
Evidence
MediTrack/services/drugInfo.ts: checks Firestore cache and falls back to external APIs, then writes results back to Firestore
MediTrack/services/useFetch.ts: generic hook providing data, loading, error, refetch and reset
UX & Visual Polish
4/10
Look and feel quality
Good surface-level polish and UX attention in places - interactive D3 visualization with tooltips and scene control, Bootstrap carousel and loading spinner - but missing broader UX patterns like skeletons, undo, or measured perceived-performance improvements.
Evidence
narrative-visualization/script.js: interactive D3 scenes, tooltip handling and annotations
21st-century-F1/src/home/index.js: Carousel with caption CTAs and responsive visuals
21st-century-F1/src/results/Results-Search.js: loading spinner for async data fetch
Verified artifacts
Expertise
React• Middle
Industries
Health Care• Middle
Technologies
Tailwind CSS
D3.js
Bootstrap
React.js
PostCSS
ESLint
React Router
React Bootstrap
Recommendations
- Develop medium-complexity SPA features that involve client-server integration and authenticated flows (for example, medication scheduling, sync and caching paths).
- Build interactive visualizations and dashboards that use D3 and React composition with emphasis on accessibility and keyboard interactions.
- Improve infra-level robustness by adding request cancellation to hooks, formal cache invalidation strategies, and basic automated tests for core logic like medCalc and drugInfo.
- Harden mobile flows by removing secrets from code, centralizing config, and adding offline/sync handling and retry strategies for network failures.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium Generalist
Full-stack developer (mid-level) focused on healthcare medication tooling and sports analytics. Strongest proven skill is backend integration and LLM-agent orchestration as implemented in MediTrack/backend/ai/agent.py and MediTrack/backend/ai/model.py. Public code does not show mature test automation, CI integration, contract testing, or performance/load testing.
Test Automation Frameworks
1/10
Building automated tests
Minimal test automation artifacts; only a trivial frontend test and lint/build scripts are present. There are no fixtures, mock servers, data factories, parallelization or selector discipline visible.
Evidence
21st-century-F1/src/App.test.js
HoopsNet/frontend/package.json
Test Coverage & Strategy
1/10
What and how to test
No evidence of a risk-based test strategy, negative-path or boundary tests, property-based tests, mutation testing, or meaningful test coverage instrumentation. The repository contains a trivial scaffold test only.
Evidence
21st-century-F1/src/App.test.js
API & Integration Testing
3/10
Testing how parts work together
Shows practical API and integration work with explicit error handling and client-side checks, but lacks contract testing, schema validation tooling, idempotency/retry scenarios or integration test containers. This is engineering-grade API integration rather than QA/contract work.
Evidence
MediTrack/backend/services/openfda.py
MediTrack/services/drugInfo.ts
HoopsNet/backend/app/main.py
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
1/10
Running tests automatically
No CI workflows, test matrices, quarantine mechanics, or failure artifact collection visible. Only project scripts (test/lint/build) appear in package files.
Evidence
MediTrack/package.json
HoopsNet/frontend/package.json
Industries
Health Care• Middle
Sports• Middle
Technologies
Python• Middle
JavaScript• Middle
TypeScript• Middle
SQLAlchemy
Uvicorn
Requests
Recommendations
- Build backend APIs and integration layers for healthcare products that require external data aggregation and LLM orchestration (use the existing MediTrack agent and OpenFDA parsing as a base).
- Develop data ingestion and ML model pipelines for sports analytics and prediction tasks, extending the existing HoopsNet model training and prediction code with CI and reproducible training scripts.
- Invest in test infrastructure: add contract tests/schema validation for APIs, negative-path and boundary tests, and end-to-end tests with fixtures or mock servers to cover critical medication-safety flows.
- Add CI workflows that run tests and collect failure artifacts, and introduce performance/load tests for any endpoints that aggregate external APIs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: