Engineering Portfolio

Systems built to automate, scale, and solve real-world inefficiencies.

Full-Stack Cloud Automation & API Integration

Daily Weather Alert System

The Problem

Forgetting to manually check the weather app in the morning leaves you unprepared for the day. I needed a reliable, automated system that pushes a personalized forecast directly to my inbox before I wake up, removing the need for manual polling entirely.

100%Delivery Rate (Port 443 Bypass)
The Architecture

A microservice-inspired architecture using Flask and React. It bypasses datacenter SMTP blockades via the Brevo REST API and utilizes a keep-alive cron mechanism to prevent cold-start timeouts for instant automated dispatch.

Repository Live Demo
Registration UI & Loading State
Registration UI & Loading State
System Architecture
Cron Trigger
TiDB Serverless
OpenWeather API
Brevo Dispatch

Inspect Node

Technical Implementation

  • ■Engineered a custom socket diagnostic tool to uncover Render's network-level SMTP (Port 587) firewall blockade.
  • ■Pivoted architecture to utilize the Brevo REST API, shifting email payloads to HTTPS (Port 443) to guarantee 100% delivery.
  • ■Implemented a 10-minute automated keep-alive polling mechanism to bypass 504 Gateway Timeouts caused by serverless cold starts.
  • ■Refactored the React frontend with asynchronous UI states to prevent database pollution from repeated API calls during server wake cycles.
ReactPython FlaskTiDB ServerlessBrevo APIOpenWeatherCron-job

Architectural Tradeoffs

External Cron Jobs vs Native Server CronNative OS-level cron jobs require paid, always-on instances. Utilizing cron-job.org for external HTTP pings achieved the exact same automated scheduling while maintaining a strictly $0 infrastructure cost.
REST API Email vs Native Python smtplibNative smtplib is cleaner locally, but cloud datacenters aggressively block standard SMTP ports to prevent spam. Sending JSON payloads over standard web ports (HTTPS/443) via REST bypassed these firewall constraints entirely.

AI Systems & Video Processing Pipeline

The Director

The Problem

Manually indexing and editing multi-hour video files creates a massive operational bottleneck. Traditional NLEs (Non-Linear Editors) require real-time human review, making high-volume content pipelines impossible to scale efficiently.

103sCore Engine Processing (668MB Payload)
The Architecture

A decoupled, asynchronous processing engine. A FastAPI backend handles FFmpeg chunking to bypass memory limits, while a concurrent LLM pipeline analyzes transcripts for narrative spikes. Output is dynamically serialized into FCPXML math for direct DaVinci Resolve timeline injection.

Repository
Upload Pipeline
Upload Pipeline
System Architecture
Upload Service
FastAPI Backend
Gemini Analysis
Resolve Export

Inspect Node

Technical Implementation

  • ■Architected an asynchronous processing pipeline handling gigabytes of video data.
  • ■Implemented AI clip ranking using contextual LLM analysis.
  • ■Built a real-time polling frontend dashboard with drag-and-drop functionality.
PythonFastAPINext.jsTypeScriptGoogle Gemini APIFFmpegConcurrent Futures

Architectural Tradeoffs

FastAPI over Next.js ServerlessNext.js serverless functions timeout on heavy FFmpeg processing. I offloaded to a dedicated Python/FastAPI worker instance to maintain persistent memory access during multi-GB video chunking.
Client Polling over WebSocketsSince video processing takes minutes (not milliseconds), maintaining persistent WebSocket connections for UI progress bars introduced unnecessary server overhead. Opted for an exponential backoff polling strategy instead.

Realtime Operations Platform

SmartQR Menu

The Problem

Traditional hospitality systems suffer from high operational latency between inventory changes and customer-facing menus. This leads to 'out-of-stock' friction and inefficient manual reconciliation across distributed staff devices.

~1.9sEnd-to-End Sync Latency
The Architecture

A real-time synchronization engine built on Supabase. By leveraging PostgreSQL's Write-Ahead Log (WAL) and WebSocket broadcasting, I achieved sub-2-second state updates from the kitchen tablet to the customer's screen over live cellular networks.

Repository Live Demo
System Auth
System Auth
System Architecture
Client UI
Supabase Realtime
PostgreSQL

Inspect Node

Technical Implementation

  • ■Integrated Supabase Realtime for automatic cross-device syncing.
  • ■Built a low-latency, mobile-first UI for immediate customer access.
  • ■Designed a simplified operations dashboard for instant inventory toggling.
Next.jsReactSupabasePostgreSQLTailwindCSS

Architectural Tradeoffs

Supabase WAL over Redis Pub/SubWhile Redis offers in-memory speed, Supabase Realtime provided sub-2-second sync speeds which is instantaneous for human operations, while keeping the stack unified and maintaining strict relational data integrity for inventory.
Client-Side Filtering over Server RenderingTo ensure maximum menu responsiveness on poor cellular connections inside restaurants, the initial payload delivers the full menu tree, allowing category switching to happen purely client-side with zero network round-trips.

Browser Extension & AI Verification Engine

Tathya-Satyapan

The Problem

Social media is saturated with unchecked, highly viral misinformation. Building an extension to combat this on infinite-scroll SPAs usually results in massive memory leaks and scrolling stutter (layout thrashing).

~60MBPeak Heap Delta (Infinite Scroll)
The Architecture

An AI-powered Chrome extension that actively monitors DOM mutations on Instagram. By implementing aggressive garbage collection and local caching, it verifies claims using the Gemini API while strictly capping memory overhead.

Repository
Extension Init
Extension Init
System Architecture
DOM Observer
Request Queue
Gemini Engine
Badge Injector

Inspect Node

Technical Implementation

  • ■Engineered a highly performant DOM monitoring system using MutationObserver and IntersectionObserver.
  • ■Profiled V8 engine heap snapshots to ensure aggressive garbage collection, capping memory overhead at ~60MB during heavy infinite scrolling.
  • ■Injected visual warning badges using DocumentFragments to prevent main-thread layout thrashing.
JavaScriptChrome APIGemini APIDOM ObserversIndexedDB

Architectural Tradeoffs

Local IndexedDB Caching vs Stateless ObserverBecause Instagram constantly unmounts and remounts DOM nodes during infinite scroll, a stateless observer would trigger infinite duplicate LLM calls. Storing verified claim hashes locally reduced API costs drastically.
MutationObserver vs API InterceptionIntercepting internal React state or private network requests is brittle and violates CORS/security policies. Using DOM observers ensures the extension remains robust even when Instagram changes their internal API structure.
In Development

Active Research

AI Job Copilot

Designing a modular AI system that analyzes job descriptions, computes candidate-job fit scores, and generates tailored resumes using strictly truthful user data. Currently architecting scalable backend pipelines using FastAPI, PostgreSQL, vector embeddings, and Playwright for intelligent automation.

FastAPIVector EmbeddingsPostgreSQLPlaywrightLLM Orchestration