Building production-ready software from concept to deployment.
I am a Full-Stack Software Engineer focused on designing reliable system architectures, automated workflow pipelines, and practical AI integrations. I take absolute ownership of software—from database optimization to production-grade DNS, CDN media routing, and real-time operational telemetry.

Production-grade systems, built and deployed.
I avoid basic tutorial exercises. The systems below were engineered to address real-world business constraints, physical infrastructure boundaries, and complex workflows.
OwnEx Properties
A premium, edge-optimized real estate marketplace engineered for automated broker lead capture and heavy media processing. Built for a real-world agency, this system tackles hard physical serverless payload limitations and custom CDN delivery rules.
Web Worker Compression
Intercepts multi-file form submissions in parallel via browser Web Workers, compressing high-res media by 80% to bypass Vercel's strict 4.5MB payload gateway limits.
SEO Indexing Engine
Engineered a self-revalidating dynamic sitemap mapping active MongoDB records to Google Search Console to guarantee immediate search engine crawling.
Event-Driven CRM Webhooks
Routes leads to Discord in under 2 seconds the moment a user unlocks a gated brochure, bypasses expensive traditional CRM overheads.

Behavior Insight Engine
An AI-native transactional intelligence engine converting messy financial text streams into structured behavioral data. Highlights advanced defensive AI design, pipeline rate-limiting, and deep trace observability drawer analytics.
Deterministic Math Separation
Strictly isolates LLM text enrichment from mathematical data calculations to guarantee 100% absolute aggregation accuracy in financial summaries.
Sliding-Window Concurrency
Throttles batch CSV processing using a client-side Promise pool (15-row chunks, 3 concurrent) to maximize throughput without hitting API rate limits.
Trace Observability Telemetry
Slide-out drawer exposing row-level confidence logs, latency trackers, and raw model output schemas to create a trust-aware environment.

KOSH Group Ledger
A high-integrity collaborative savings engine implementing manual susu/chit-fund style contribution scheduling. Architected to enforce complex financial penalty logic, strict transactional state locks, and zero-leak database modeling.
Contribution Penalty Schedules
Automates scheduled contribution windows and calculates late-payment penalties capped strictly at 40% to preserve ledger fairness.
Transactional Mutation Locks
Prevents account self-termination or group deletions before full campaign fund distribution, guaranteeing zero-leak financial liquidation.
Relational Lifecycles
Models complex schema states mapping collaborative campaigns from initial draft validation through active state to equal payout execution.

// 02 / Competencies
Proven engineering capabilities, mapped to actual system deployments.
Full Stack Development
Building end-to-end web applications from UI to backend services.
AI Product Engineering
Building deterministic AI workflows rather than simple chat interfaces.
Production & Infrastructure
Deploying, maintaining, and operating production-ready systems.
Developer Workflow & Collaboration
Managing codebases, project ownership, deployment workflows, and professional handovers.
R&D Technologies
Technologies and domains I actively explore through experiments, prototypes, and side projects.
// 03 / R&D Lab
Experiments born from curiosity, research questions, and occasional side quests.
Life OS
“Can an interface change how we relate to memories?”
An experiment in storing memories as folders and files inside nostalgic devices.
The project explored whether interfaces themselves can become emotional artifacts rather than simply containers for content.
ThreadShield
“What if moderation was a workflow problem instead of an automation problem?”
A Reddit moderation experiment that started as an AI helper and slowly evolved into a workflow obsession.
The most interesting discoveries came from reducing friction rather than increasing automation.
ScreamCursor
“What if a cursor could panic?”
An experiment in turning a perfectly normal cursor into a highly stressed digital creature.
The project explored how personality and emotional feedback can emerge from tiny interaction details.
Currently Exploring
Active ExplorationDeveloper tools, programming languages, and interfaces I am currently researching and prototyping.
// 04 / Core Tenets
A review of personal software engineering principles and operational methodologies.
I build software because I enjoy understanding how complex systems behave, why users interact the way they do, and what happens when you push an idea far enough to make it real. For me, programming isn't a passive activity—it is a continuous cycle of building, shipping, and learning.
Sometimes, the systems I build address strict commercial requirements and scale in production—like engineering multi-threaded client-side image compression to bypass Vercel payload constraints, or implementing transactional locks on group ledgers. Other times, they are playful investigations into human-computer interaction, like giving a desktop cursor an emotional state.
Both paths are equally important; production systems demand absolute rigor and operational compliance, while side experiments build the deep, native curiosity that makes a better software engineer.
How I Learn
My learning loops are entirely project-driven. I don't read documentations in a vacuum; I write prototypes. If I want to understand concurrency boundaries, I write promises. If I want to learn Go, I build local developer tooling. Experimentation is the fastest way to turn abstract computer science theories into practical knowledge.
My Approach
I view engineering through the lens of absolute ownership. Clean code is useless if the deployment pipeline fails, or if the CDN costs spiral. Effective software design is about managing tradeoffs: balancing client CPU overhead against server budgets, keeping bundle sizes light, and setting up strict observability.
Operating Principles
Simple systems scale better than clever ones.
Avoid premature abstractions. Write readable, predictable code that is easy to understand, maintain, and eventually delete.
Measure behavior, not assumptions.
Decisions should be driven by telemetry, real user workflows, and production metrics rather than hypothetical design theories.
Build first, optimize later.
Verify the architecture and validate user impact with a functional prototype before investing time in micro-optimizations.
Current Focus
Active engineering domains and platforms I focus on developing, building, and refining:
// 05 / Get in Touch
Initiate communication, request tech consultations, or discuss open positions.