Second-year AIML student. My main interest is backend systems — I want to understand what breaks under concurrency, how queues fail, and where consistency gets hard. I build things to answer those questions, not to ship products. Also contribute to open source projects in the API tooling and Linux kernel workflow space. Alongside systems work, I've built with scikit-learn, LSTMs, and spaCy — enough to understand where ML fits and where it doesn't.

Async job engine in Go. Worker pool, full state machine (PENDING → SCHEDULED → RUNNING → SUCCEEDED/FAILED/RETRYING), exponential backoff, graceful drain on shutdown. Built primarily to work through real concurrency and failure-handling problems.

Three specific things I had to debug and fix:

Scheduler race — Multiple scheduler instances polling the same DB table would double-claim jobs. Fixed by wrapping job claims in SELECT FOR UPDATE SKIP LOCKED inside a transaction. Each instance atomically acquires a non-overlapping job set.

Silent retry loops — Unregistered executor types caused jobs to hit max retries silently, burning resources with no signal. Added explicit error classification: missing executors and panics route directly to FAILED; only actual execution errors are retryable.

Import cycle — Attaching Prometheus instrumentation to the worker package created a worker → api → worker dependency cycle. Resolved by extracting metrics into a standalone package imported independently by both.

v1 done. Currently exploring Redis/Kafka-backed queues as an alternative to DB polling and adding priority scheduling.

GitLab AI Hackathon — ZerothLayer.

Static analysis pipeline that scores pull request risk before review. The LLM generates the human-readable summary at the end — it does not do the analysis.

Pipeline:

• tree-sitter parses changed files into ASTs (Python + JS/TS)
• NetworkX builds the import dependency graph; BFS reversal computes structural blast radius
• Six deterministic factors produce a 0–100 risk score: PR size, file churn rate, whether auth/payment modules were touched, test delta, dependency traversal depth, author familiarity with the module
• Groq (Llama-3.3-70b) generates reviewer hints from the structured score — not from raw diff text

The design decision I'm most satisfied with: keeping the LLM downstream of deterministic scoring so the risk number is auditable and reproducible regardless of model behavior.

Hackathon prototype. On-chain prediction market with streak-based multipliers built on Solana devnet using Rust/Anchor. Main focus was understanding Anchor's account ownership model, escrow logic, and how bet payout instructions get structured on-chain. Not actively maintained.

• Microcks — API mocking and contract testing; active contributions
• OpenTelemetry — Contribution under review
• kworkflow — Linux kernel developer workflow tooling
• Meshery / Layer5 — Contributor, earned First Design badge
• Hacktoberfest 2024 — 4 PRs merged

• Extending Orchestrix with Redis/Kafka queue backend; want to understand the operational tradeoffs vs DB polling under load
• Working through Raft and consistency model literature (Lamport clocks, CRDT basics)
• Contributing to Microcks, OpenTelemetry, kworkflow

_{Stats reflect public repository activity.}