Projects & systems

At TCS, I own the data platform behind a Fortune-500 bank's batch operations. It pulls job status out of the bank's mainframe, stores it, and powers the dashboards and alerts the client's operations team lives on. I designed the query engine, the failure tracking, and the system that predicts an SLA miss before it happens. The result: our most important batch job went from ~15 minutes to under 1 minute, and the platform now flags problems before the client ever sees them. Under the hood: Python, Oracle, and MongoDB, with a config-driven SQL engine and 85% test coverage across the codebase.

• Cut the core batch job from ~15 minutes to under 1 (93% faster), with results verified unchanged
• Predicts SLA misses before they occur, using job-calendar data
• Catches silent data failures early, instead of after the client does
• 85% test coverage, clean static analysis, and structured logging (70% less log volume)

I run my own large language model on a single desktop machine — no cloud, no external API. I set up the model, the serving, and the tooling so it can be driven like any other API. On top of that I built an automated pipeline that turns 80 work records into a deduplicated, evidence-traced memory where every output carries its source. The hard part isn't the model — it's making a model that can be wrong produce output you can trust and trace. Under the hood: an NVFP4-quantized Qwen 27B model, a 262K-token context window, and an OpenAI-compatible API via SGLang (migrated from vLLM behind the same contract).

• A 27B model running locally on one 128 GB desktop box — no cloud
• 262K-token context, exposed as an OpenAI-compatible API
• Automated pipeline: 80 records, zero missed after fallback, every output traceable to its source
• Hybrid deduplication that only escalates ambiguous cases to the model

This app classifies email across all your connected accounts (iCloud, Gmail, Yahoo, work) entirely on your Mac — nothing is sent to a cloud. You define folders in plain English, and it files mail accordingly, learning from how you actually sort things over time. A companion iPhone app lets you approve or reject decisions and watch it run live. It's a product where the model is just one component — the privacy architecture and the decision logic are the real engineering. Under the hood: Swift, Apple's on-device Foundation Models by default (or open-weight models you run locally), with multi-account support.

• Zero email content leaves the machine — local models only
• 30,000+ of my own emails classified across multiple accounts
• Folders defined in plain English, and it learns from your corrections
• Companion iPhone app: approve/reject and live status, with no on-phone inference

This is a notes app where no plaintext content ever touches disk. Each note is encrypted with its own key, and that key is wrapped to a hardware security chip on the device — so a copy of the file is useless without it. I implement the handwriting shape recognition from first principles, tuned to refuse rather than guess at ambiguous strokes. It's a project about doing cryptography and hard algorithms correctly, with an adversarial review pass that caught a real security flaw before it could ship. Under the hood: Swift 6, zero third-party dependencies, 6,400 lines of app code backed by 295 automated tests.

• No plaintext note content ever reaches disk
• Per-note encryption keys wrapped to the device's Secure Enclave
• Adversarial crypto reviews caught a real error oracle before it could ship
• Hand-drawn shape recognition built from first principles — refuses to guess