M.S. Computer Science, University of Florida · Dec 2025 · GPA 3.8 📍 Chicago, IL
I build backend and infrastructure systems that stay correct when failures, concurrency, and regressions make behavior hard to reason about.
if you_read_one_thing:
→ 7 PRs merged into Temporal's production Go SDK by their maintainers.
→ Not a tutorial project. Not a clone. Code real engineers use, that I fixed.
| 7 merged Temporal PRs |
1,500+ failure scenarios · Faultline |
0.93 root-cause confidence · DetTrace |
+333% p95 spike caught · KubePulse |
I don't just build my own systems — I've shipped fixes into ones other engineers depend on.
|
🌀 Temporal Go SDK —
|
☁️ Azure SDK for Go |
🧱 Faultline — distributed job execution correctness
0.0% duplicate commits across 1,500+ injected failures — vs. 12 on a naive queue under the same load.
How it works ↓
Lease-based job systems have a hole: lease expiry stops the next worker from starting — it doesn't stop the old worker from writing late after it recovers from a crash. That stale write is what corrupts ledgers and causes double-charges.
Faultline closes the hole at the database boundary, not in app logic — a UNIQUE(job_id, fencing_token) constraint in Postgres means a recovered worker holding a stale token gets rejected by the DB itself. Each claim increments a token; a late commit from an old token is rejected because it's no longer the newest one, full stop.
Ships with a reconciler that repairs incomplete jobs, a Go inspector API for live lease-risk state, and Prometheus/OTEL instrumentation for stale-rejection rate and claim latency.
Python (primary) Go (inspector API) PostgreSQL Docker Prometheus OpenTelemetry
🌐 KubePulse — release-safety validation across the stack
Caught a release where p95 latency spiked +333% while every Kubernetes readiness probe stayed green.
How it works ↓
Readiness probes check whether a container is alive — not whether the release is safe. KubePulse runs a 4-layer gate (health signals → network validation → SLO/error-budget check → probe-integrity divergence) and issues an explicit ship/block decision.
Underneath the Kubernetes layer is a real networking lab: a two-AS eBGP topology (FRRouting, Linux network namespaces) with measured 251ms median / 270ms p95 data-plane recovery across 10 fault-injection runs — plus a Layer-2 lab (VLAN trunking, 802.1Q, router-on-a-stick) where a deliberately broken trunk isolated 100% packet loss to a single VLAN, diagnosed and rolled back with packet-capture evidence.
Python FastAPI Kubernetes Terraform FRRouting Prometheus Docker Compose
🔬 DetTrace — first-failure isolation via deterministic replay
Finds where execution first diverged — not just where it eventually broke. 0.93 root-cause confidence across 10,000+ validations.
How it works ↓
Debugging distributed failures is asymmetric: failures are easy to see, hard to locate — logs record state changes after they happen, and the event that actually caused the failure often isn't logged at all.
DetTrace generates an expected deterministic trace, replays the divergent execution, and binary-searches to isolate the first divergence index. Validated across 20 I/O transport scenarios (SPI, I2C, UART, GPIO races, distributed retry storms) with 47 GoogleTest cases passing clean under AddressSanitizer and UndefinedBehaviorSanitizer.
Honest about its limits — the README documents a ~7% false-positive rate and states plainly that firmware scenarios are trace simulations, not kernel-level implementations. That's the kind of thing worth saying out loud in an interview, not hiding.
C++17 CMake GoogleTest Swift Python (FastAPI)
🤖 AgentGrid — making AI agent failure modes observable
Gated a release to HOLD instead of shipping it — because averaging hides exactly the failure you need to see.
How it works ↓
Production GenAI systems fail quietly: retrieval misses the right doc, a tool call returns a stale result, an answer generates without grounding — and one aggregate pass-rate number hides all of it.
AgentGrid instruments every stage (triage → retrieval → tool execution → generation → eval gate → optional human review) with per-stage metrics, and gates releases on retrieval hit rate, tool success rate, p95 latency, and drift. Current state: 80% retrieval hit rate, 80% tool success rate, 880ms p95 — held, not shipped, with the hold reason surfaced explicitly. 57 tests passing.
Python FastAPI React/TypeScript Redis Prometheus
🗂️ More projects
- FairEval — blocks AI releases that regress under real serving load
- AccelSim-Lite — names throughput/latency bottlenecks and gates the regression
- AutoOps-Insight — detects CI/CD failures before they reach production
- Enterprise Process Lab — validates ERP integrations and controls compliance
Meta × MLH — Production Engineering Fellow June – September 2026
- Deployed and operated a Linux-hosted Flask service on a cloud VPS — SSH, DuckDNS routing, Python virtualenv, tmux-based process persistence
- Automated redeployment with a Bash script covering 6+ manual steps: GitHub sync, repo reset, dependency install, stale-process cleanup, service restart
- Built Bash/Python automation for API parsing, regex matching, and Apache log analysis across a 237MB dataset — extracted 2.9M+ unique source IPs and HTTP status-code distributions
| Languages | Python · Go · C++ · Java · SQL · Bash · JavaScript |
| Backend | REST APIs · FastAPI · PostgreSQL · distributed job execution · concurrency · idempotency |
| Infrastructure | Kubernetes · Docker · Terraform · AWS · GitHub Actions |
| Systems | Linux · TCP/IP · distributed systems · fault tolerance · transactional correctness |
| Observability | Prometheus · Grafana · OpenTelemetry · Datadog |
