where I've done this
Experience
Senior Engineer II, PowerSchool
- Redesigned attendance-report generation from eager, per-recipient generation to on-demand delivery via unique links, cutting a job that had run up to twelve hours.
- Led a zero-downtime migration of transactional email, upwards of 300,000 sends a day, to a new provider without degrading deliverability.
- Recovered wrongly decommissioned customers after a bad-ID incident, then rebuilt decommissioning into a single script that resolves every data relationship itself, closing the gap that caused it.
- Serve as a go-to engineer for complex production behavior, mentoring others while driving system-level improvements.
Product Engineer, Shuru Technologies
- Joined as one of the first engineers at a startup that pivoted from a training platform into hiring, rebuilding core parts of the app across frontend, backend, and infrastructure as it shifted.
- Built the internal ATS a 10-person ops team ran hiring on, replacing an off-the-shelf recruiting CRM and spreadsheet-based tracking.
- Automated content ingestion for the training product, taking instructor-authored material straight into the backend without engineering involvement.
Software Engineer, Betacraft Technologies
- Worked across multiple client engagements in healthcare and fintech, each with its own domain and constraints.
- Led development of a compliance and continuing-education platform for clinicians, built on a rules engine for requirements that varied by state and changed continuously.
- Integrated with partner systems to pull and reconcile compliance data across sources.
- Contributed to technical design with client stakeholders and mentored interns.
Systems Engineer, Infosys
SAP Basis operations. Early exposure to enterprise systems and production discipline.
what I've built at work
Systems
A few systems I've shaped end to end.
Redesigned attendance report generation
PowerSchool · shippedAttendance reports for parents were generated eagerly for every recipient the moment a job ran, spawning upwards of 100,000 sub-jobs and hammering the database for reads. For large customers around dates like month-end, a single job could take twelve hours to finish.
How it worked
The eager generation matched no real requirement, it was just how the legacy system worked. Report open-rate data showed parents almost never opened a report the moment it was delivered. The redesign replaced eager generation with a unique link per recipient and generated the report on open instead of on send, removing the database load for documents nobody was about to read yet. It shipped, and daily queue-latency alerts have already dropped as a result.
Zero-downtime email vendor migration
PowerSchool · shippedMoved transactional email, upwards of 300,000 sends a day, onto a new provider. Mail delivery is the primary function of the system it runs in, so the migration itself couldn't be allowed to degrade it.
How it worked
The obvious approach is swapping API keys. At that volume it's also the wrong one: a new sending IP has no reputation with mail providers, and a cold IP taking full volume on day one gets treated as spam. A router ramped traffic onto the new provider up to a computed daily maximum, with everything above that falling back to the old one, so delivery never depended on the new IP earning trust faster than it could.
Rebuilt the customer decommission workflow
PowerSchool · shippedCustomer decommissioning purges PII from the database, backing the data up first in case it's needed later. The parent-child relationships that decide what gets purged were validated by hand, and a few less obvious ones sat outside that coverage — until an engineer decommissioned the wrong customers off a bad ID, and that gap became the actual failure mode.
How it worked
I led getting the wrongly purged customers back live: writing scripts that pulled the deleted rows out of the pre-purge backup and reinserted them, restoring the accounts with no lasting data loss. The fix that followed replaced manual validation entirely: decommissioning is now a single script that resolves every parent-child relationship itself, including the ones the original process missed, so nothing outside it needs a human to check first.
Internal ATS for a hiring platform
Shuru · 2021–2023The system the operations team ran hiring on: job posting and lifecycle, interview pipelines, candidate filtering and flagging, and the outreach data recruiters worked from. Ten people used it every day.
How it worked
Before it, hiring ran on an off-the-shelf recruiting CRM alongside spreadsheets for tracking candidates. It was built as a v2 while the existing system kept running, so the ops team could move across when it was ready. Once they did, recurring operational work came off engineering.
Content ingestion for the training product
Shuru · 2021–2023Instructors authored the course material: videos, quizzes, questions, and answer keys. This pipeline took what they produced and loaded it into the backend with no engineer in the loop.
How it worked
Content nested as modules, sub-modules, lessons, and quizzes, with each quiz holding a handful of questions. A question could be video, image, text, or a combination of them, which meant the client had to render every shape and the API had to stay generic enough to describe them all instead of special-casing each one. Instructors named their files against a convention agreed up front, and the ingestion script used that convention to resolve each asset onto the right place in the structure.
Compliance platform for clinicians
Betacraft · 2019–2021A platform helping clinicians track and meet continuing-education and compliance requirements, built on a rules engine that encoded a demanding, ever-changing set of regulations.
How it worked
Requirements varied by state and by license type, and they kept changing, so the platform had to absorb updates rather than be rewritten around them. Most of them fitted one underlying model. The remaining fifth were ambiguous enough in interpretation that the rules engine had to grow new capability before it could express them at all, and that minority is where most of the work went. It also integrated with partner systems to pull and reconcile compliance data across sources.
what I've built on my own time
Side projects
Self-directed builds, 2026 — most with Claude Code as a pair-engineer.
Vision-language model, from the ground up
trained · validatedA frozen SigLIP2 vision encoder and a frozen Qwen2.5-0.5B language model, bridged by a projector with roughly 1.5 million trainable parameters — the only part of the model that ever learns anything.
How it worked
Each image becomes 196 patch embeddings from SigLIP2, gets projected into Qwen's embedding space, and is concatenated with the tokenized caption before a single forward pass through the frozen LLM — next-token prediction loss, with image and padding positions masked out so gradients only ever flow back into the projector. Proving it actually learned something, rather than the LLM's language prior doing all the work, meant comparing the trained projector against a randomly-initialized one on the same images: random produced incoherent garbage, trained produced specific, mostly-correct captions — though not perfect, it missed the dog entirely in one skiing photo, catching the gist while dropping secondary detail. Running it on COCO's held-out validation images, never seen in training, kept that same coherence, which is the part that actually confirms generalization instead of memorization.
Image and caption, generated together
trained · demo pendingA single random seed produces both a stylized engraving and its caption, with neither derived from the other — both come from one shared latent representation, so nothing gets illustrated or captioned after the fact.
How it worked
A shared seed doesn't guarantee the image and caption agree on their own — a small MLP turns it into a latent that feeds a LoRA-tuned Stable Diffusion branch on one side and a GPT-2 branch on the other, reading that same latent as a soft prompt prefix and never seeing the actual pixels. Both branches could learn to look plausible while quietly drifting apart. The fix was a coherence loss: every 10 training steps, generate a real image and caption from the same latent, run both through CLIP, and penalize any semantic mismatch directly instead of hoping shared conditioning was enough. Trained for around 2,500 steps over a few hundred engraving images, with caption loss dropping from ~4.0 to ~0.5 and the coherence loss stabilizing alongside it. The gnarliest bug wasn't in the model at all — a network-mounted filesystem was silently corrupting checkpoint writes to 0 bytes, caught only after it started eating training runs. A checkpointed model runs end to end locally now; a public demo is next.
Agent harness for product development
building · write-up soonBuilt my own harness for agentic coding rather than taking one as given: a toy project first, then rebuilt against a real product with real requirements as the gaps showed up.
How it worked
Parallel execution is still the open problem: running multiple agent tasks against a codebase without them stepping on each other. I'm studying how existing harnesses solve it and folding what works back into mine. Planning to publish the harness and what it's built.