Category: Embedded Systems, Edge Computing

Overview

Developed an end-to-end IoT device emulator stack that reproduces how an embedded device communicates with cloud services through a layered gateway architecture. The system enabled full device-to-cloud testing without requiring physical hardware.

What I Built

• Implemented MCU firmware simulation for telemetry generation and command handling
• Built gateway services to bridge MCU-side communication and cloud connectivity
• Implemented MQTT-based telemetry and command exchange with AWS IoT Core
• Added telemetry buffering to reduce data loss during network interruptions
• Built end-to-end command routing from cloud services to the emulated device
• Implemented an OTA update agent to support device software update workflows
• Added service supervision and containerized process management for runtime reliability
• Designed the stack to support integration with a Rust + Slint desktop GUI for monitoring and control

Tech Stack

C, Python, MQTT, AWS IoT Core, SQLite, Docker, systemd, Unix sockets, Rust, Slint

Outcome

Created a modular IoT emulator stack that enabled rapid validation of telemetry, command routing, and OTA update flows without physical hardware. The architecture provided a practical foundation for device-to-cloud testing and future evolution toward Rust-based edge services.

Links

• Codebase: Private company repository

Category: Natural Language Processing, Information Retrieval

Overview

Implemented and evaluated a Retrieval-Augmented Generation (RAG) system for multi-hop factoid question answering across a 609-document corpus and 2,556 queries, comparing retrieval strategies and downstream language models to improve answer relevance and factual consistency.

What I Built

• Implemented a two-stage experimental pipeline covering retrieval evaluation and downstream RAG answer generation
• Compared six retrieval variants including BM25 sparse retrieval, dense bi-encoder retrieval, hybrid sparse-dense fusion, and cross-encoder reranking
• Integrated top-ranked retrieval outputs with four instruction-tuned 7B language models: Falcon, Dolphin, Qwen2, and Mistral
• Evaluated retrieval performance using Hits@10, MAP@10, MRR@10, and NDCG@10
• Evaluated answer generation quality using Precision, Recall, F1, and ROUGE-L
• Analyzed how retrieval quality and LLM behavior interact across inference, comparison, and temporal query types

Tech Stack

Python, BM25, Sentence Transformers, Cross-Encoder Reranking, PyTorch, scikit-learn, Hugging Face Transformers

Outcome

Dense retrieval methods substantially outperformed the BM25 baseline on multi-hop queries, with Rankers E and F achieving the strongest retrieval performance. In the generation stage, the Falcon/F pipeline achieved the best overall balance, reaching F1 = 0.28 and ROUGE-L = 0.29, showing that stronger semantic retrieval and instruction-tuned generation together improved answer quality for multi-hop QA.

Links

Category: Finance, Generative-models, Time-series

Overview

Built a deep learning pipeline to generate synthetic Limit Order Book (LOB) sequences using TimeGAN, aiming to reproduce realistic statistical and temporal patterns of high-frequency financial market data for simulation and analysis.

What I Built

• Developed a preprocessing pipeline to convert raw high-frequency LOB snapshots into sequential model-ready training data
• Engineered 43 standardized LOB features from LOBSTER AMZN Level-10 data, including relative prices, log-transformed volumes, spread, mid-price return, and imbalance
• Implemented a full TimeGAN architecture with Embedder, Recovery, Supervisor, Generator, and Discriminator modules using GRU-based recurrent networks
• Trained the model in two phases: supervised reconstruction / latent transition learning followed by adversarial refinement
• Performed hyperparameter tuning with Optuna across 20 trials to identify more stable configurations
• Experimented with an enhanced variant using empirical latent sampling, AR(1) latent correlations, stronger regularization, and extended training
• Evaluated synthetic data quality using KL divergence, SSIM, AR(1) temporal gap, latent divergence, and representative heatmap comparisons

Tech Stack

Python, PyTorch, NumPy, Pandas, Matplotlib, Optuna

Outcome

The project successfully produced a working TimeGAN pipeline for synthetic LOB generation and improved training stability through tuning and enhanced latent modeling. However, the final models did not meet the target realism thresholds: KL divergence and SSIM remained well outside target ranges, and the generated depth maps were still overly smooth compared with real market data. The project highlighted both the feasibility and the practical difficulty of applying GAN-based sequence generation to high-frequency financial microstructure data.

Links

Category: Cloud Computing, Big Data Analytics

Overview

Built a cloud-based analytics environment on GCP to support large-scale e-commerce data processing using containerized tools, distributed storage, and notebook-based analysis workflows.

What I Built

• Provisioned and configured a GCP VM for cloud-based analytics workflows
• Set up Docker and Docker Compose to run the analytics environment
• Deployed Jupyter Notebook for interactive analysis on the cloud instance
• Moved large CSV datasets into the working environment and HDFS for scalable access
• Used PySpark to load, combine, and preprocess product and review datasets
• Performed exploratory analysis on cleaned data, including customer behavior and price-related patterns

Tech Stack

Python, PySpark, Docker, Docker Compose, HDFS, Jupyter Notebook, GCP VM

Outcome

Successfully deployed a working cloud analytics environment for handling large e-commerce datasets and demonstrated practical experience in combining cloud infrastructure, distributed storage, and notebook-based data analysis.

Links

Category: Sports Analytics, Motion Analysis

Overview

Built a machine learning pipeline to detect motion anomalies in table tennis swings and analyze how swing consistency relates to player experience using large-scale wearable sensor data.

What I Built

• Preprocessed and analyzed 97k+ swing motion records
• Implemented anomaly detection using Isolation Forest
• Built experience-level prediction models using Ordinal Logistic Regression and XGBoost
• Performed model tuning and evaluation under class imbalance conditions
• Analyzed relationship between anomaly frequency and player experience

Tech Stack

Python, Scikit-learn, XGBoost, Pandas, NumPy, Matplotlib

Outcome

Models successfully identified anomalous swing patterns and showed that higher-experience players generally exhibit more consistent motion with fewer anomalies.

Links

Category: Full-Stack · AI Systems · Cloud Deployment

Overview

Planor is a B2C AI-powered room design tool built for a furniture design company. Customers click "Start Design" on the retailer's website, complete a short style and budget survey, upload a photo of their room, and receive AI-generated furniture recommendations matched to their preferences — which they can drag and drop directly onto a live canvas of their own space.

I designed the system architecture from scratch and built the entire frontend across all stages of the design flow, together with the backend scaffolding, typed API client, auth middleware, and deployment pipeline. My teammate contributed the GCP and Azure AI service implementations and the JWT Bearer auth integration; I integrated both into the application composition root and wired the end-to-end system together.

What I Built

Architecture & Documentation

• Designed the full system architecture: Next.js 16 frontend on Vercel, .NET 8 REST API on Google Cloud Run, Supabase Auth + PostgreSQL, GCP Vertex AI (Gemini 2.5 Flash + Imagen 3)
• Wrote the architecture reference doc, developer guide, and product-flow specification as the internal team source of truth

Frontend (10 pages)

• Covered every page: root, /login, /register, /consent, /welcome, /design/upload, /design/analysis, /design/preferences, /design/canvas, and the root layout
• Built the onboarding wizard (OnboardingModal) — 3 steps collecting budget, style preference, personality, lifestyle, and room type; saves to localStorage and feeds directly into the AI request
• Upload page supports drag-and-drop and click-to-browse, validates file type and size (20 MB cap), converts to base64, and stores in sessionStorage for the next step
• Analysis page calls the AI backend on load, shows what it detected (room type, dominant style, existing furniture), and stores the result for downstream steps
• Preferences page fetches the product catalog, filters by the user's budget and style, and lets them choose between refining specific pieces or a full redesign

Canvas — 4 components

• CanvasBoard — the main editor area: room photo as background, segmented furniture as individual draggable layers, and catalog products the user drops in; drag-and-drop via @dnd-kit
• ProductPanel — sidebar of catalog products shown as draggable cards, loaded from the API
• EditPanel — controls for whichever item is selected: rotate, scale, tilt, opacity, material, duplicate, remove
• LayersPanel — shows each layer in the scene with visibility toggles, and has the button that triggers the segmentation call to break the room photo into moveable pieces

API Client & Type System

• Built lib/api.ts — centralized, typed API client with automatic Supabase JWT injection, a custom ApiError class with status/body/endpoint context, and clean domain namespaces: products, recommendation, segmentation
• Built types/index.ts — 14-interface TypeScript type system mirroring the C# backend models exactly, covering the full API contract: catalog items, survey answers, AI analysis / transform / refine request and response shapes, segmentation layers, canvas state, consent records, and user preferences

Auth & Middleware

• Built Next.js middleware.ts — server-side route protection enforcing: unauthenticated users redirect to /login; authenticated users without consent redirect to /consent; authenticated users with consent proceed through the design flow; authenticated users on auth pages redirect to /welcome
• Wired Supabase Auth client and server helpers, consent record creation on register, and post-login redirect logic across login, register, and consent pages

Backend Scaffolding & Integration

• Set up the .NET 8 multi-project solution structure (HomeStyle.UI, .Services, .Data, .Models), CORS policy allowing localhost and *.vercel.app, rate limiting on AI endpoints (10 req/min per user), and the pluggable AI provider toggle (GCP / Azure)
• Scaffolded RecommendationController, ProductsController, and SegmentationController; wired SupabaseProductRepository with a MockProductRepository fallback for dev environments
• Integrated my teammate's JWT Bearer auth implementation and AI services into Program.cs, with a safe dev-mode fallback when JwtSecret is absent and a hard startup failure if secrets are missing in production

Deployment

• Configured multi-stage Dockerfile and deploy.sh for Cloud Run deployment with environment variable injection
• Wired Vercel frontend deployment with env vars, CORS origin allowlist, and environment separation between local and production

Tech Stack

• Frontend: Next.js 16, React 19, Tailwind v4, @dnd-kit, Supabase Auth
• Backend: .NET 8, ASP.NET Core, JWT Bearer (HS256)
• AI: GCP Vertex AI — Gemini 2.5 Flash + Imagen 3
• Auth: Supabase Auth → JWT → ASP.NET Core validation
• Database / Storage: Supabase PostgreSQL (PostgREST), Supabase Storage
• Deploy: Vercel (frontend) + Google Cloud Run (backend)

Outcome

Delivered a working end-to-end alpha of the Planor platform: a fully auth-protected frontend across 10 pages, a JWT-secured .NET API, an AI pipeline that analyses uploaded room photos and returns placement suggestions via Gemini 2.5 Flash and Imagen 3, and a drag-and-drop canvas for building and refining room designs. The system is designed as a B2B2C widget intended to be embedded on furniture retailers' websites, turning browsers into buyers through a personalised, room-native design experience.

Links

• Codebase: Private repository

Category: GenAI, Multimodal RAG, Agentic Systems

Overview

Built a RAG agent that answers questions about a user's personal travel history and recommends new destinations, grounding every answer in a synthetic knowledge base of 20 past trips (photos, captions, structured metadata) instead of relying on generic LLM world knowledge. Awarded a Top 10 Best Project Award for INFS4205/7205.

What I Built

• Designed a 9-node LangGraph StateGraph pipeline: a deterministic keyword-heuristic query router fans out in parallel (via the Send API) to up to four retrieval backends, merges results with Reciprocal Rank Fusion, optionally reranks, then extracts preferences and generates a grounded answer
• Indexed each trip across four independent retrieval modalities: dense text (all-MiniLM-L6-v2, 384-dim) and cross-modal image (CLIP ViT-B-32, 512-dim, averaged per trip) in separate ChromaDB collections, plus an in-memory metadata tag-scorer and a BM25Okapi lexical index
• Implemented Reciprocal Rank Fusion (k=60) to combine heterogeneous retrieval signals, and tested three query-aware pruning strategies (soft/mid/strict) to reduce latency without sacrificing recall
• Built an optional RankGPT-style LLM reranker with a silent fallback to the original fusion order on parse failure
• Wrote query-type-specific prompts: a strict grounding-only prompt for memory-lookup queries, and a separate recommendation prompt that explicitly excludes already-visited destinations
• Designed and ran a 12-variant ablation study (15 queries, 4 query families, 18 evaluation turns) measuring Recall@3, MRR, keyword overlap, LLM-as-judge groundedness, and NLI-based groundedness (cross-encoder/nli-deberta-v3-small)
• Built an offline Stable Diffusion XL pipeline to generate seeded, category-aware travel photos per trip, and a SHA-256 content-hash-based reindexing system robust to file moves/copies
• Shipped a Streamlit UI with Chat, Index, and Results tabs for interactive querying and ablation result inspection

Tech Stack

Python, LangGraph, ChromaDB, sentence-transformers, open-clip-torch (CLIP ViT-B-32), rank-bm25, Kimi K2.6 (via OpenAI-compatible API), Streamlit, diffusers (SDXL)

Outcome

The full fused pipeline achieved a Recall@3 of 0.481 and MRR of 0.750 against a baseline of 0.000 for both metrics, with LLM-judge groundedness reaching 0.909 versus zero for the ungrounded baseline — demonstrating that retrieval-grounded generation substantially outperforms generic LLM recommendations on personalized travel tasks. The ablation study also surfaced real limitations: equal-weight RRF fusion can dilute a strong single-modality signal (CLIP-only retrieval alone beat the fused pipeline on raw Recall@3), analytical multi-hop queries requiring synthesis across the full knowledge base remained an unsolved failure mode, and the project explicitly identified (but did not attempt) learned cross-modal projection to unify the incompatible MiniLM/CLIP embedding spaces as future work. The project was awarded a Top 10 Best Project Award out of the full course cohort.

Links

• Codebase: Private repository
• Project Report: Coming soon

Category: Backend Systems, Platform Engineering, Infrastructure

Overview

Contributing to FrostFlow's transition from Proof-of-Concept to MVP, focused on re-architecting the platform's data layer and building out core backend systems for user identity, authorization, and compliance. Work is ongoing.

What I Built (in progress)

• Participating in the architectural migration of the platform's data layer from a planned relational (Aurora) design to DynamoDB, covering feasibility assessment, trade-off analysis, and full schema design across all core domain entities (users, organizations, devices, sessions, integrations)
• Built the backend for user registration and onboarding, including Cognito-triggered account provisioning, profile management, and a legally-compliant waiver acceptance flow using atomic multi-table transactions
• Designed and implemented a shared authorization middleware pattern applied across the platform's protected API endpoints
• Contributed to infrastructure modernization, including a Terraform migration from CDKTF to native HCL and cleanup of legacy AWS resources
• Participated in major architecture and planning meetings shaping the platform's MVP direction

Tech Stack

AWS Lambda, API Gateway, DynamoDB, Aurora, AWS Cognito, Terraform (HCL), TypeScript, Node.js

Status

In progress — MVP development ongoing as part of FrostFlow's platform buildout.

Links

• Codebase: Private company repository

Category: Backend Systems, Cloud Platform

Overview

Built the backend platform for FrostFlow’s Proof-of-Concept, focused on ingesting device telemetry and wearable health data, normalizing them into a unified model, and exposing APIs for internal Web UI and system validation.

What I Built

• Implemented serverless REST APIs for telemetry, device state, command dispatch, and health data access
• Designed and applied a canonical health data model to normalize wearable metrics across integrations
• Built backend ingestion flows for Fitbit data using OAuth2 authorization and server-side token exchange
• Stored telemetry and health samples in DynamoDB using time-series oriented access patterns
• Developed a lightweight internal Web UI to validate end-to-end device → cloud → UI behavior and support command testing

Tech Stack

AWS Lambda, API Gateway, DynamoDB, TypeScript, Node.js, Fitbit Web API, OAuth2, Internal Web UI

Outcome

Validated the FrostFlow backend architecture for ingesting telemetry and wearable health data into a unified cloud platform. The PoC established a working serverless API layer, Fitbit integration flow, normalized health data model, and internal Web UI for end-to-end system verification.

Links

• Codebase: Private company repository

Category:

Full-Stack / Backend / Cloud Deployment

Overview

Shiroku is a post-payment monitoring and anomaly detection platform designed for solo founders and small business owners. The product focuses on helping merchants detect unusual refund spikes, transaction anomalies, and other post-payment issues without needing enterprise-scale tooling.

I worked on Shiroku as a full-stack product and engineering project, covering backend development, deployment, CI/CD, release workflow design, and production environment setup. The platform includes a FastAPI backend, a React frontend, Docker-based local development, and production deployment across Vercel and Railway. The application also includes a waitlist-first landing page integrated with branded domain email onboarding.

What I Built

I built and refined the backend and deployment foundation for Shiroku, with particular focus on release quality, developer workflow, and production readiness.

On the backend side, I worked with FastAPI, SQLAlchemy, Alembic, and PostgreSQL to support a structured application foundation for uploads, transaction analysis, authentication-related flows, and future anomaly detection services. I also worked within a Docker-based local setup so the application could be developed and run consistently across environments.

On the product delivery side, I implemented and hardened the CI/CD pipeline. This included:

• separating automated test execution from image publishing
• making Docker image publishing depend on successful test completion
• creating a manual dev to main release workflow
• hardening the release workflow with preflight checks for stale release branches, tags, and partial reruns
• aligning main back into dev after release so versioning remained consistent for future releases

I also helped establish the production deployment flow using:

• Vercel for the frontend
• Railway for the backend and database
• GHCR for Docker image publishing
• custom domains including shiroku.app and api.shiroku.app

A major part of the work was not just shipping code, but designing a release process that was safe enough to use repeatedly as the project matured.

Tech Stack

• Frontend: React, Vite, Tailwind CSS
• Backend: Python, FastAPI
• Database: PostgreSQL
• ORM / Migrations: SQLAlchemy, Alembic
• Data Processing: Polars
• Email / Waitlist: Resend
• Deployment: Vercel, Railway
• Containers / Infra: Docker, GitHub Container Registry (GHCR)
• CI/CD: GitHub Actions

Outcome

The result was a working production setup with a cleaner engineering workflow behind it.

By the end of this phase, Shiroku had:

• a live branded frontend at shiroku.app
• a live branded backend API at api.shiroku.app
• a test-gated CI pipeline so broken dev changes would not publish images
• a manual but structured release workflow from dev to main
• a follow-up alignment process to keep dev and main on the same release baseline
• a stronger foundation for future beta and product expansion

This project was especially valuable because it forced me to move beyond just writing features and into real release engineering decisions: versioning, environment setup, deployment safety, branch strategy, workflow recovery, and production consistency.

Links

• Shiroku