Full-stack engineer and founder. I validate the problem first, then use software and applied AI to solve it.
Previously Quality Engineering Intern at Wellth · Open to Software Engineering & AI Implementation roles
Shopify agencies waste hours manually testing checkout after every deploy. TestPilot AI automates that entirely — giving every store a live health score so you never have to test by hand again.
Designed and shipped the full-stack system using Playwright, Node.js, and React to automate checkout validation and trigger tests after deploy.
Frontend: React dashboard — test flows, run history, and alerting UI.
Backend: Node.js/Express — Playwright automation engine, REST API for triggering and managing test runs, persistent storage for artifacts and logs.
Infra: Railway. Shopify deploy webhooks trigger automated runs on each deployment.
Designed the Playwright-based automation runner to simulate real user checkout flows. Architected backend APIs to trigger runs manually or via webhook. Designed Shopify-specific checkout handling including variant selection via API and cart injection before UI validation. Engineered a run classification system to detect checkout success, UI failures, and navigation errors. Implemented retry logic and failure thresholds to reduce false alerts. Added screenshot and log artifact generation for debugging.
Unreliable UI across themes: Designed a hybrid approach using API-based cart insertion and flexible role/text-based selector fallbacks.
False positives: Implemented retry system with delay — only alert after consecutive failures.
Partial page loads: Combined URL checks, DOM content validation, and form detection to distinguish real failures from transient issues.
Outcome: Reduced manual checkout testing from ~30 min per deploy to fully automated runs with actionable failure insights.
Attorneys lose $1,000+ per month in forgotten billable time. Speak your work — get properly formatted legal billing entries in seconds. Built for ProLaw and Clio.
Designed and shipped the mobile app and backend to convert voice input into structured legal billing entries using OpenAI APIs.
Mobile: React Native / Expo — voice input, matter selection, billing entry output with copy-to-clipboard.
Backend: Node.js API on Railway — handles transcription input, OpenAI integration, and prompt processing.
AI Pipeline: Speech → transcription → LLM formatting into structured billing entries (0.1 hr increments, action-oriented phrasing).
Infra: Railway (backend), EAS (Android APK builds), Vercel (landing page). Clio-compatible workflows.
Designed the mobile-first voice interface for capturing work logs. Architected the backend API to process transcription input and generate structured billing entries. Designed prompt templates to normalize messy voice input into professional legal billing language. Implemented domain-specific formatting rules including action-oriented phrasing and standardized entry structure. Kept OpenAI keys server-side by decoupling the app from any direct AI calls.
Unstructured voice input: Designed prompt templates to enforce consistent formatting and normalize inconsistent speech.
Legal billing standards: Generic AI outputs aren't billable — fine-tuned prompts for legal tone and added formatting validation.
Frictionless UX: Optimized the flow to speak → process → display instantly with minimal steps.
Outcome: Eliminates end-of-day time reconstruction — structured, ready-to-use billing entries immediately after input.
Full-stack serverless application on AWS with JWT auth, REST APIs, and infrastructure fully provisioned via Terraform.
Frontend: Static site on S3. Backend: AWS Lambda (Node.js) behind API Gateway. Data: DynamoDB. Auth: Cognito with JWT via API Gateway authorizer. Infra: Fully provisioned via Terraform.
Designed and provisioned the complete infrastructure using Terraform. Implemented Lambda functions for data operations. Integrated JWT authentication via Cognito and API Gateway authorizer.
Lambda event handling: Standardized request parsing for API Gateway v2 event structure.
Auth integration: Configured Cognito issuer and JWT validation, debugged unauthorized responses.
Full-stack app that cuts document review time by 70% using AI-generated summaries with source highlighting and confidence scoring.
Frontend: React (TypeScript) — document upload and summarized output display. Backend: Node.js API — input processing and prompt orchestration. AI Layer: Gemini API with structured prompts.
Designed the frontend and backend pipeline. Engineered prompt strategy for concise, context-preserving summaries. Implemented text chunking to handle large documents within model context limits.
Accuracy: Structured prompts with constraints to reduce hallucination.
Large inputs: Chunked text before processing to stay within context limits.
Automated data extraction pipeline achieving 85%+ accuracy for receipt parsing — turning unstructured images into structured expense data.
Processing: Tesseract OCR for text extraction. Post-processing: Python and Pandas for data cleaning, normalization, and structured output.
Designed the extraction pipeline. Engineered post-processing logic to parse raw OCR output into structured fields — item names, prices, totals. Added data cleaning and flexible pattern-based parsing for inconsistent receipt formats.
Noisy output: Applied text normalization and filtering rules.
Inconsistent formats: Designed flexible pattern-based parsing to handle layout variation.
Cloud-connected inverter monitoring system using AWS IoT Core and MQTT for real-time telemetry streaming. Serverless backend exposes REST endpoints; DynamoDB handles low-latency device data storage in an event-driven, distributed architecture.
Device Communication: MQTT over AWS IoT Core. Backend: Lambda triggered by IoT rules. API: API Gateway REST endpoints. Storage: DynamoDB for low-latency telemetry.
Designed the MQTT topic structure for efficient routing. Configured AWS IoT Core for device communication. Engineered Lambda functions to process and store telemetry. Exposed REST endpoints via API Gateway for data consumers.
Real-time streaming: Designed publish/subscribe model for continuous device-to-cloud flow.
Event-driven architecture: Structured Lambda triggers from IoT rules for reliable async processing.
I design and ship AI-powered applications across mobile, backend, and automation systems. I've launched products for checkout flow monitoring and AI-driven legal billing, and gained experience in quality engineering at Wellth. I prioritize problem validation first — then move quickly to deliver practical, production-ready solutions. I started building after seeing how inefficient real workflows were — from legal billing to ecommerce testing — and now focus on solving those gaps with software.