Henil C Alagiya
Full Stack AI Engineer | Building Autonomous Systems
Hi, I'm Henil, a Software Engineer based in New Jersey with a deep focus on Full-Stack Development and AI integrations.
I recently completed my Master's in Computer Science at NJIT and am spending my time building robust, real-world software, particularly focusing on leveraging AI and integrating Large Language Models (LLMs) into intelligent systems.
I am actively seeking full-time Software Engineering or AI Engineering roles anywhere in the United States. If your team is building something exciting, I would love to connect!
I completed my Master of Science in Computer Science at the New Jersey Institute of Technology (NJIT) in Newark, NJ. My coursework focused heavily on advanced computational models, AI systems, and modern software architecture, and I graduated with a 3.55 GPA.
I worked as a Software Engineer at iTechCloud Solution Pvt Ltd in Surat, Gujarat. I rapidly progressed from an Intern to independently driving engineering efforts for enterprise-grade Salesforce workflows.
I architected and deployed internal applications using Lightning Web Components (LWC) and Apex to streamline hiring processes. I developed complex automation flows that eliminated nearly 90% of manual operations, utilizing REST API integrations to seamlessly connect Salesforce with external data systems.
I started my career as a Software Developer (Part Time) at Infiycube Solution alongside my undergraduate studies. I collaborated on multiple full-stack web applications, engineering dynamic user interfaces with React.js and Next.js, and implementing robust data architectures using PostgreSQL and MongoDB.
Balancing my studies with professional development, I built foundational RESTful APIs and integrated third-party services that set the stage for my later enterprise integrations.
I earned my Bachelor of Engineering in Computer Engineering from Gujarat Technological University (GEC Rajkot), graduating with a CGPA of 7.13. Here, I built my core foundation in algorithms, data structures, and object-oriented programming.
Projects
- Next.js, FastAPI, PostgreSQL
A job aggregation platform designed for candidates, providing the latest job listings alongside built-in application tracking.
Problem Statement: Job hunting requires constantly refreshing multiple company career pages to find the latest openings, while simultaneously using messy spreadsheets to keep track of where and when you've applied.The Idea: To build a centralized platform specifically for candidates where they can easily discover the newest job postings, and use built-in tools to track their applications and progress all in one place.Solution:- Architected a distributed data pipeline deployed on GCP Linux VMs, scaling to parse and normalize over 160+ job records per second.
- Engineered an incremental synchronization daemon linking PostgreSQL with Typesense (Vector Search), delivering sub-100ms full-text search latency.
- Built a responsive, server-side rendered frontend using Next.js to display fresh opportunities and track candidate pipelines in real-time.
- Python, LangChain, LangGraph, ChromaDB
A high-performance RAG chatbot system using Context Padding to prevent AI hallucinations and provide deeper context.
Problem Statement: In RAG systems, we mainly face a balancing act: too much context causes hallucinations, while too little fails to provide enough information. Additionally, standard context vectors often retrieve isolated snippets, missing the critical surrounding details needed for a complete answer.The Idea: To solve the context paradox, I used 'Context Padding'—retrieving small, precise vector matches but expanding the window to include surrounding text before passing it to the LLM. This gives the AI the 'full picture' without diluting the search accuracy.Solution:- Utilized LangChain to orchestrate the hybrid retrieval pipeline (dense + sparse search) and re-ranking logic for precise context fetching.
- Implemented LangGraph to manage the conversational state, allowing the system to "remember" context and perform complex query rewriting.
- Deployed ChromaDB as the high-performance vector store, optimized to handle the custom "context padding" embeddings and metadata filtering.
- JavaScript, Chrome Extension API
A Chrome extension that watches the DOM and actively filters out noisy, promoted LinkedIn job postings in real-time.
Problem Statement: Scrolling through LinkedIn felt like a waste of time—seeing the same 'Promoted' ads and jobs I'd already applied to over and over again. I just wanted to see fresh, relevant opportunities without the noise.The Idea: The browser knows what it's rendering. I decided to inject a script that 'watches' the page build process. As soon as a job card appears, the script checks its properties (like 'Promoted') and removes it from the code often before it's even painted to the screen.Solution:- Utilized MutationObserver API to monitor the DOM changes in real-time, removing ad elements before they are painted to screen.
- Implemented Vanilla JavaScript filtering logic to inspect job properties against user-defined criteria (Remote/Hybrid/Easy Apply).
- Python, AppleScript, MCP
An MCP translation layer via AppleScript that enables local AI agents to seamlessly view and edit macOS Apple Notes.
Problem Statement: I love using AI to organize my thoughts, but it was frustrating that my local LLMs couldn't actually see or edit my Apple Notes. I wanted a way for my AI agents to seamlessly manage my personal knowledge base right where I keep it—on my Mac.The Idea: Apple Notes acts like a walled garden to outside software, but it speaks 'AppleScript'. I built a translation layer: a Python server that accepts modern JSON commands from the AI and 'translates' them into the native AppleScript commands that the Notes app understands.Solution:- Utilized FastMCP framework to expose Apple Notes functionality as a standardized Model Context Protocol server for agents.
- Implemented AppleScript bridges to execute native macOS commands, enabling Python to "drive" the local Notes application.
- Integrated Pydantic for robust input validation, ensuring that agent commands match the strict schema required by the tools.
- Python, Google Sheets API, MCP
An MCP wrapper for the Google Sheets API that gives AI agents tools to strictly read, write, and format spreadsheets autonomously.
Problem Statement: Connecting AI agents to spreadsheets usually felt clunky or limited. I wanted my AI to do more than just read cells—I needed it to truly 'drive' Google Sheets, handling complex data tasks autonomously like a real analyst.The Idea: Spreadsheets are just data grids with rules. I treated Google Sheets not as a UI, but as a set of callable functions. By wrapping the Google API in an agent-friendly protocol (MCP), I gave the AI specific tools to 'see' and 'touch' the data directly.Solution:- Utilized FastMCP to wrap 25+ Google Sheets API endpoints into agent-ready tools for read, write, and formatting operations.
- Implemented Service Account Authentication to ensure secure, non-interactive access suitable for production backend environments.
- Integrated Pydantic models to strictly validate data types before sending requests to the Google API, minimizing runtime errors.
A headless, event-driven quantitative trading bot that processes market data and technical indicators in milliseconds.
Problem Statement: I realized that no matter how fast I reacted, I couldn't beat the market's speed or ignore my own emotions during volatile trades. I built QuantBot to take 'me' out of the equation—executing strategies instantly and purely based on data, 24/7.The Idea: Speed comes from removing friction. I removed the human bottleneck by building a 'headless' listener. It connects directly to the data stream, and purely mathematical logic decides to buy or sell—skipping the visualization step entirely to save milliseconds.Solution:- Utilized Pandas & NumPy to vectorise market data processing, enabling the system to evaluate strategies across millions of data points in milliseconds.
- Implemented Event-Driven Architecture to decouple data ingestion from execution logic, ensuring sub-second reaction times.
- Integrated TA-Lib to compute real-time technical indicators (RSI, Bollinger Bands) dynamically as new ticks arrive.
- Django, Python, PostgreSQL, Fyers API
A headless, event-driven quantitative trading bot that processes market data and technical indicators in milliseconds.
Problem Statement: In scalping, every millisecond counts. I found myself missing perfect entry points just because I was too busy calculating strike prices and fumbling with order forms. I needed a tool that could keep up with my thinking speed.The Idea: In scalping, thinking time is losing time. The idea was to 'pre-load' the gun. The system constantly calculates the correct strike price in the background, so the 'Buy' button is always armed with the perfect order parameters, requiring zero setup from the user at the critical moment.Solution:- Utilized Fyers Data API to subscribe to live WebSocket feeds for real-time index tracking and ATM strike calculation.
- Implemented a Unified API Adapter in Python to normalize order execution endpoints across different brokers (Zerodha, Upstox).
- Engineered the One-Click Execution Engine to pre-construct API payloads, eliminating manual form-filling latency.
Certifications
- Introduction to Model Context ProtocolAnthropic · Oct 2025
- Salesforce Certified AI AssociateSalesforce · Oct 2024