Selected
Works.
Here's the curated selection of what I'm most proud of. The whole is always greater than the sum of its parts, but sometimes, the parts can be pretty big on their own. In those cases, where one massively-scoped project encapsulated multiple standalone sub-projects, I've broken them apart. Some of these ship to real users, some I built to learn, and a couple are still under construction and experiencing rolling updates.
Lustr is an early-stage cleaning and sanitation startup I co-founded, starting with mobile automotive detailing. I own and operate the full software stack end to end: booking, memberships, scheduling, admin tooling, and the ops surfaces behind it. Shipping this to real customers has taught me more than any class project ever could.
Skills exercised
Highlights
- ▹Built and shipped a production full-stack platform for booking, scheduling, payments, and CRM. Real users, real revenue, real on-call.
- ▹Built and shipped a full-stack platform on React (Vite), Supabase/Postgres, Stripe, and Vercel that now runs real customer bookings and payments.
- ▹Implemented a conflict-aware scheduling engine with slot holds, overlap detection, crew-capacity logic, and DB locking to keep booking state consistent under concurrent checkout traffic.
- ▹Built a full booking + membership flow: draft-persistent multi-step wizard, cart checkout, recurring subscriptions, and customer-facing account management.
Database Administration
This is the database backbone for everything Lustr does in production: bookings, payments, memberships, and CRM events. I built it RLS-first, pushed critical writes through stored procedures, and wired forward-only migrations into CI so changes don't get messy. I keep exact table and policy details private here because this system handles real customer and payment data.
Highlights
- ▹Production Postgres architecture on Supabase: ~30 tables, ~95 RLS policies, ~55 RPC procedures, and ~30 edge functions guarding money, scheduling, and secrets.
- ▹Roughly 30 tables across user identity, booking and availability, service and pricing catalog, membership and credit accounting, payment and order history, admin notes, notifications, and co...
- ▹RLS enabled on every user-facing table, with ~95 policies in four tiers: user-owned data keyed on the caller's auth identity, admin-only tables gated on a role helper, public-read catalog ta...
- ▹Stored procedures are the only write path for anything that touches money, scheduling, or credits. ~55 procedures handle availability calculation, hold/confirm/cancel lifecycle, reschedule,...
Brand & Marketing Design
I built Lustr's visual identity end to end, from logo system and type/color tokens to flyers, social creative, business cards, and in-app illustration. The same person writing the product code also shaped the brand language, which kept the product and marketing voice consistent from day one.
Highlights
- ▹Designed Lustr's brand from the ground up: logo, typography, social assets, and print collateral, all in Figma.
- ▹Designed Lustr's logo and brand system — typography, color palette, and component tokens — used consistently across the iOS app, web booking flow, and marketing surfaces.
- ▹Authored marketing collateral in Figma: launch flyers, social graphics, neighborhood door-hangers, business cards, and seasonal promo materials. Iterated against real conversion data from ea...
- ▹Built a small design library so non-designers (the ops team, partners) can produce on-brand assets without breaking the system.
Paid Acquisition & Ad Attribution
Lustr's paid channel runs on Instagram and Facebook. I own it end to end — the Meta Pixel and Conversions API integration that makes the data trustworthy, the creative that goes into the ads, the targeting and budget decisions in Meta Ads Manager, and the ROAS review that tells me which ads to kill and which to scale. The attribution infrastructure is what makes the rest possible: without server-side events, Meta's optimizer is flying blind on roughly a third of real conversions.
Skills exercised
Highlights
- ▹Wired up Meta Pixel + server-side Conversions API to recover the 30–40% of conversions that ad blockers and iOS ATT would have erased, then ran conversion-objective campaigns on Instagram an...
- ▹Built a dual-path attribution stack: browser-side Meta Pixel fires on every page and SPA route change, plus a server-side Conversions API call fires from the Stripe webhook after payment cle...
- ▹Six events instrumented: PageView, Lead (contact form), CompleteRegistration (verified signup), Schedule (booking confirmed), Purchase (Stripe payment), Subscribe (membership activated). The...
- ▹Server-side CAPI runs from the payment webhook, not the browser — it bypasses ad blockers, iOS App Tracking Transparency, and strict-mode browsers entirely. Pixel-only setups lose 30–40% of...
DevOps & Release Engineering
This is the release and reliability system behind Lustr. I set up the dev-to-staging-to-main flow, hotfix backports, branch previews, migration deploys, and guardrails that block frontend promotion when backend migrations fail. It lets us move fast day to day without rolling broken changes into production.
Highlights
- ▹Built a release pipeline that lets us ship fast without breaking prod: layered branching, two CI gates, staged deploys, and migration-gated promotion.
- ▹Three-tier branching (dev/* → stg → main) with a hotfix/* lane that bypasses stg in emergencies and auto-opens a backport PR with auto-merge enabled, so a hotfix can never silently regress o...
- ▹Two PR gates. Gate 1 (PR into stg): Vitest plus a smoke Playwright suite (~6 critical specs covering auth, booking wizard, cart, checkout, membership, dashboard) against a fresh local Supaba...
- ▹Vercel previews per branch. dev/* and stg builds deploy to per-branch Vercel preview URLs gated behind Vercel team auth, scoped to the staging Supabase project and Stripe sandbox. Production...
Multi-Task Vision Model
This is an internal ML system for estimating job effort and condition from interior and exterior intake photos. It runs seven prediction heads, feeds outcomes back into a retrain loop, and promotes new versions only when they beat the current model. I designed it as a practical operations tool first, not a demo, so it can keep getting better as real job data grows.
Highlights
- ▹Building a self-improving vision model for detailing ops that predicts effort, contamination, and vehicle class directly from intake photos.
- ▹Multi-task architecture with a pretrained ResNet18 image encoder fused with tabular service/context features. Seven prediction heads share a common feature representation: vehicle group (3-c...
- ▹Trained on intake photos collected from real Lustr operations, joined to crew-clocked job durations from the booking database. Interior and exterior labor times are tracked separately per jo...
- ▹Vehicle subtype accuracy 89.4% (top-1, 10-class) on the held-out test set, 95% CI [86.1, 92.0]. Interior labor MAE 8.2 min vs. 14.6 min for the prior flat-lookup estimate. Exterior labor MAE...
Affiliate Partner & NFC Attribution System
Lustr's growth problem is one every local service business faces: you can't buy Google Ads into profitability on a finite crew calendar. The affiliate system is the answer — a network of partner businesses (gyms, car dealerships, body shops) each holding a branded NFC card that, when tapped or scanned, drops a first-party attribution cookie and routes the customer to self-book. The same infrastructure extends to social media influencers: a unique /r/<code> link works in an Instagram bio just as well as on a physical card. I designed and built the entire system from the DB schema to the partner portal UI.
Skills exercised
Highlights
- ▹Built a full affiliate attribution stack — NFC/QR referral cards, Vercel edge middleware, Stripe webhook stamping, tiered commission engine, and a partner portal — to turn physical business...
- ▹Designed the NFC card distribution model: each partner business receives a branded physical card programmed to their unique lustrservices.ca/r/<code> URL. Customers tap or scan at the partne...
- ▹Built Vercel edge middleware for the /r/<code> attribution hop: resolves the referral code via an anon-callable RPC, sets a first-party HttpOnly + readable cookie pair (48h, Secure, SameSite...
- ▹Threaded attribution through the full payment stack: the readable cookie passes affiliate_ref into the checkout body, both checkout edge functions re-validate it server-side, and the Stripe...
Circle: Building the Anti-LinkedIn for Students
Circle is a venture I am building with a small team for students and early-career users who do not feel served by traditional professional platforms. We are still in design, but we have already run deep discovery with professors and students and secured interest for a real classroom beta once the product reaches that stage.
Skills exercised
Highlights
- ▹Co-founding a student-first professional network with peer circles, institutional hubs, and AI-assisted planning, shaped by heavy user research.
- ▹Co-founded a venture building a platform that merges the approachability of Discord/Reddit with the professionalism of LinkedIn, aimed at academics and early-career users who feel invisible...
- ▹Grounded the product in 50+ interviews with professors and 100+ interviews with students to surface where their actual academic workflows break down, and what tooling would close the gap. Th...
- ▹Already accepted for a small beta testing run with real student users in real classrooms once we hit the beta stage. Still in the design phase today, but the pilot pathway and willing partne...
Tile-Level Machine Learning DSL Compiler
I built this compiler to learn modern ML compiler architecture by actually building one end to end. A single tile-level source language lowers into a custom MLIR dialect, then branches into CPU and GPU targets without changing frontend code. One language, two backends, working pipeline.
Highlights
- ▹Built a Triton-style tensor DSL with a full ANTLR4 to MLIR to LLVM pipeline and dual backends for CPU AVX2 and GPU tensor cores.
- ▹Tile-typed surface language with explicit shape, layout, and memory-space attributes (`Tile<f32, [BM, BK]>`, `tile.load`/`tile.store`), plus a separate schedule block with Halide/Triton-styl...
- ▹Five-pass static type checker with clang-style diagnostics (`file:line:col: error:`, notes, hints, source-line carets). Catches shape mismatches, dangling iter-var references, invalid bind d...
- ▹Custom `tile` MLIR dialect as the connective tissue between backends. ODS/TableGen for op declarations and verifiers; standard pattern-rewrite for transformations; ANTLR4 → AST → tile dialec...
CPU x86 AVX2 Target
This is the CPU side of the compiler. The same source kernel flows through linalg, memref, and scf into LLVM IR and then AVX2 assembly. Most of the work is in schedule-aware optimizations like fusion, vector-width clamping, and loop parallelization.
Highlights
- ▹Implemented the x86-64 AVX2 backend for the tile DSL, lowering real kernels to assembly through the standard MLIR and LLVM toolchain.
- ▹Lowering pipeline: `tile` → `linalg` + `memref` + `scf` → LLVM dialect → LLVM IR → x86-64 assembly via `llc -mtriple=x86_64 -mattr=+avx2`. Five inspectable intermediate artifacts (tile-diale...
- ▹Schedule-driven vector-width clamping: the user's `vectorize <op> width=N` directive is a hint; apply-schedule clamps it against the target ISA (AVX2 fp32 caps at 8, AVX-512 at 16) and recor...
- ▹Vertical fusion: a `tile.elementwise` whose first operand is a `tile.matmul` result folds into the matmul as a `fused_epilogue` attribute, the canonical "matmul + bias + activation" optimiza...
GPU NVIDIA NVPTX Tensor-Core Target
This is the GPU backend for the same tile DSL. Kernels lower through gpu and nvgpu dialects with explicit global-shared-register movement, cp.async staging, and mma.sync tensor-core ops. Same frontend contract, different optimization problem.
Highlights
- ▹Implemented the NVIDIA GPU backend with memory-space-aware lowering and tensor-core matmul via nvgpu.mma.sync.
- ▹Extended the `tile` MLIR dialect with a GPU lowering path targeting NVIDIA sm_80: `tile` → `gpu` + `nvgpu`, ready for NVVM and PTX. Architecture is read off the schedule's `target` directive...
- ▹Memory-space-aware lowering: tiles carry a memory-space attribute (global / shared / register), and the pass emits the right primitive per transition. Global-to-shared becomes `nvgpu.device_...
- ▹Tensor-core matmul: the inner body lowers to `nvgpu.mma.sync` (mmaShape=[16, 8, 16], fp16 in, fp32 accum), the canonical Ampere form. The pattern validates tile dimensions against the mma-sh...
Gazprea was a full-compiler build in CMPUT 415, and we treated it like real engineering, not just coursework. Our team owned parsing, typing, lowering, runtime support, and CI-backed regression testing across a huge suite. We finished first in the course and were invited to present the work in an academic exchange with HSBI in Germany.
Skills exercised
Highlights
- ▹Built a full research-language compiler in a 4-person team: ANTLR4 frontend, rich type system, MLIR pipeline, LLVM backend, and 2k+ tests.
- ▹Nine-pass pipeline: ASTBuilder → ScopeAnalyzer → RoutineRecorder → TypeResolver → QualifierEnforcer → TypeChecker → TypeCastValidator → FinalJudgmentVisitor → CodeGenVisitor. Built on a 342-...
- ▹Polymorphic TypeInfo hierarchy (BasicType, ArrayType, VectorType, TupleType, StructType, IntervalType, TypeAliasRef) with an ArrayBase abstraction that unifies indexing, slicing, concatenati...
- ▹MLIR codegen using six standard dialects (Arith, SCF, Func, MemRef, Math, ControlFlow), lowered through a seven-stage pipeline (FuncToLLVM → SCFToCF → MathToLLVM → ArithToLLVM → MemRefToLLVM...
RISC-V Snake Game
This was my deep dive into low-level systems work at the core of a Computer Architecture course. The capstone was a complete Snake implementation in RISC-V assembly running on RARS MMIO primitives, with keyboard and timer interrupts sharing one trap path, event-driven game-state updates, and rendering optimized to redraw only what changed each tick. It was a practical way to build interrupt handling, MMIO I/O, and state management directly in assembly. There are also a few honorable-mention projects in the full write-up!
Highlights
- ▹Built a full event-driven Snake game in raw RISC-V assembly with MMIO interrupts, custom trap handling, and efficient incremental redraws.
- ▹Built a complete event-driven game loop in raw RISC-V assembly with keyboard and timer interrupts routed through one trap path.
- ▹Implemented incremental redraw logic so each tick updates only changed cells instead of repainting the whole board.
- ▹Wrote collision detection, movement state transitions, apple spawning, and score/timer handling directly over MMIO primitives.
Native Android Application: Event Scheduling
This was a team-built Android app for users, organizers, and admins handling real event workflows from signup to check-in. We built it end to end on Firebase with QR generation and scanning, waitlist lottery logic, role-based routing, and admin tooling.
Highlights
- ▹Built a multi-role Android event platform in Java with QR check-in, lottery selection, and Firebase-backed lifecycle management.
- ▹Built a three-role Android app (users, organizers, admins) with Firebase-backed event flows from signup to check-in.
- ▹Implemented QR-based attendance and waitlist lottery logic with state transitions for invites, enrollment, and organizer controls.
- ▹Added admin cleanup flows that remove related event/user data across Firestore and Firebase Storage.
BookNook: ESL Research Contribution
BookNook was a research and engineering collaboration with SFU Linguistics, and the software itself was the research output. We built a platform that lets students in multilingual classrooms read the same content in the language they are strongest in, including languages that are usually ignored by edtech tools. I served as product owner across five two-week sprints while also contributing implementation work.
Skills exercised
Highlights
- ▹Shipped a multilingual reading platform with a 7-person SFU team, supporting 200+ languages including low-resource classroom languages.
- ▹The platform itself is the research contribution. Delivered as a seven-person collaborative team effort for the Simon Fraser Dept. Linguistics: scoped, prioritized, and shipped 300+ user sto...
- ▹Architected a FastAPI backend (14,000+ lines Python, SQLAlchemy ORM) with a 5-stage asynchronous PDF processing pipeline (upload, OCR extraction via PyMuPDF, confidence-threshold review gati...
- ▹Built an LLM-powered adaptive quiz system (Groq API) generating questions across 3 Bloom's taxonomy difficulty tiers; enforced quiz eligibility via a state machine gating on reading progress...