M.S. Computer Science, University of Florida · Dec 2025 · GPA 3.8
📍 Chicago, IL
Open to relocation across the U.S.
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 |
58 tests · Faultline |
+228% p95 regression caught · 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
Fencing alone still produced 2 duplicate charges when a worker was killed mid-remote-call. Idempotency produced 1. Measured across a 4-strategy matrix on real Celery, Redis, and PostgreSQL.
How it works ↓
Fencing tokens stop a stale owner from committing late, but they can't help when the new owner is legitimate and the real question is whether a remote side effect already happened. Faultline injects real SIGSTOP/SIGKILL faults into live workers, runs each failure against naive, fencing, idempotency, and fencing+idempotency strategies, and checks explicit invariants after recovery.
In the ambiguous-remote scenario, a worker is killed after a remote charge succeeds but before it learns the result. Naive and fencing-only both end with 2 external charges (fencing accepted both commits, since the second worker was a legitimate owner). Idempotency and fencing+idempotency end with 1 charge and 1 suppressed duplicate. 58 tests, two adapters (Celery, BullMQ), four invariant checkers (three reported on every Celery run).
Scope is deliberately narrow: no claim of universal exactly-once execution, linearizability proofs, or production certification of Celery, BullMQ, or Redis.
Python Celery BullMQ Redis PostgreSQL Docker Compose
🌐 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
Compares baseline and candidate OpenTelemetry traces per request shape and fails CI on regression. On a checkout flow, POST /checkout p95 went 43.04 ms → 141.30 ms and errors 0% → 20%, while the GET /health cohort had too few samples to judge and was reported INCONCLUSIVE instead of being flagged.
How it works ↓
Averaging all traffic into one latency number hides endpoint-specific regressions. DetTrace groups traces by request shape (root service, operation, HTTP method/route), then compares latency, error rate (in percentage points), span-graph structure, and critical-path contribution for each cohort independently.
Ships as a reusable GitHub Action, and was independently validated against standard OpenTelemetry Collector output and the OpenTelemetry Astronomy Shop demo app (POST /ship-order p95 24.00 ms → 1015.23 ms). It grew out of an earlier deterministic-replay core (first-divergence isolation), which is still in the repo.
Honest about its limits: the critical-path algorithm is built for tree-structured traces and doesn't claim causal correctness for arbitrary asynchronous DAGs, and per-span p95 deltas aren't an additive decomposition of the end-to-end delta. That's the kind of thing worth saying out loud in an interview.
Python OpenTelemetry C++17 Swift
🤖 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.
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 |
