Personal portfolio · Est. Frisco, TX
Distributed systems, proven under fire.
I build distributed systems and the machine learning that runs on top of them: Raft consensus hardened by fault injection, HNSW vector search over embeddings, transformer-based NLP for crisis triage. USACO Gold, published in a peer-reviewed journal, and a USA Cricket U19 athlete ranked 31st nationally when I'm away from the terminal.
export const abhineeth = {
name: "Abhineeth Duddela",
based: "Frisco, TX",
school: "Heritage High School", // class of 2027
focus: ["consensus", "NLP", "inference"],
research: "peer-reviewed · published",
computing: "USACO Gold",
tutoring: 2_500, // students reached
cricket: { squad: "USA U19", rank: 31 },
status: "open for opportunities",
} as const;I'm Abhineeth, a rising senior at Heritage High School in Frisco, TX. My work sits where machine learning meets distributed systems: the models that make a prediction, and the infrastructure that has to keep serving them when a node dies mid-write. Most of what's on this page started as a question I couldn't answer by reading (how does a cluster actually agree under partition, what does an HNSW graph look like while it's searching) and ended as something I had to implement to find out.
I fine-tune transformer architectures, ship reproducible statistical tooling in R and Python, and reverse-engineer the messy parts of the internet, from disaster-response tweet streams to K–8 tutoring logistics. I'm a published researcher in a peer-reviewed journal, a USACO Gold competitor, a data-science intern under a Harvard preceptor, a nonprofit co-founder whose research reach spans three countries and five U.S. states, and a USA Cricket U19 athlete ranked 31st nationally.
My north star is unreasonably simple: build technically elegant systems that meaningfully compound in the real world. Whether that's an ensemble NLP classifier triaging emergency signals, a Bayesian pedagogy module deployed to an international bootcamp, or a lean edtech operation serving 2,500+ students, I optimize for depth, reproducibility, and reach.
Consensus, vector search, distributed training and incompressible flow, implemented from the primary literature rather than pulled off a shelf. Each card opens on a drawing of the mechanism it describes; the first three also run live in your browser further down the page.
A queued-delivery transport with per-link drop_prob and
delay_ticks, asserting election safety, leader completeness and
state-machine safety per tick across a 600-seed randomized sweep.
TF-IDF over 1–2 grams into L2-regularized logistic regression, chosen so
Shapley values reduce to the closed form φⱼ = wⱼ(xⱼ − E[xⱼ]).
Attributions are exact, not Monte-Carlo sampled.
Hand-written HNSW over 384-dim MiniLM embeddings: M=16,
ef_construction=200, cosine on L2-normalized vectors, built with
SELECT-NEIGHBORS-HEURISTIC. Zero network calls.
Incompressible Navier-Stokes on WebGPU compute shaders, over a MAC staggered grid so that divergence and gradient are exact negative adjoints and the checkerboard pressure mode a collocated grid hides cannot form. Pressure projection is solved five ways (conjugate gradient and an exact FFT solve on CPU; Jacobi, red-black Gauss-Seidel and a geometric multigrid V-cycle on GPU) so the comparison between them is measured rather than claimed. Vorticity confinement is a fabricated energy source, so the solver throws if a validation run asks for it.
Three systems that were already built and tested separately, a Raft consensus engine, an HNSW index and a training framework, composed into one platform and driven from outside as read-only dependencies. Each passes its own suite, and none of those suites says anything about a training worker dying at the instant the storage cluster splits in half. The first bug the cross-layer harness found was exactly that shape: Raft behaved correctly, HNSW behaved correctly, and every replica in the cluster crashed.
Data-parallel SGD with gradients synchronised each step by ring all-reduce or a parameter server, and six invariants checked on every step against a single-process reference rebuilt by a route that shares no arithmetic with the production path. The reduction sums in canonical worker-id order, since float addition is not associative and without a fixed order bitwise replica agreement fails intermittently and looks like a race. Four of the six findings published on the report are defects in this repository's own harness, two of which would have produced a confidently wrong result.
Raft implemented from the primary paper: randomized-timeout leader election via
RequestVote, AppendEntries replication with
prevLogIndex/prevLogTerm consistency checking, and
quorum commit advancement restricted to the leader's current term (the Figure 8
constraint). Deterministic discrete-event simulator with injected crashes,
restarts and partitions; 23 tests including live asyncio TCP transport tests that
kill a server mid-write and confirm zero data loss through failover.
Asynchronous Monte Carlo Tree Search for LLM-guided code generation with a modified
UCB1 policy that discounts high-token-cost branches by remaining budget:
Q(s,a) + c·√(ln N(s)/N(s,a)) − λ·(τ(s,a)/B_remaining). Enforces
RLIMIT_AS, RLIMIT_CPU and wall-clock limits on untrusted
generated code, validated against real infinite loops and memory-exhaustion
attempts. A self-reflection loop feeds execution tracebacks back into model context.
17 tests, zero external ML dependencies.
Multi-term university scheduling modelled as a joint CSP/optimization problem, and it is NP-hard: credit-limit bin-packing combined with precedence-constrained graph colouring for prerequisites. Dual backends: an OR-Tools CP-SAT integer program doing two-phase lexicographic optimization (minimize terms-to-graduation, then maximize course quality under a fairness constraint), and a dependency-free backtracking search with topological ordering and time-budgeted fallback. Catalogs from five universities, modelling both semester and quarter calendars.
Co-founded a vertically integrated K–8 tutoring company connecting high-school tutors with students in Math, Science, Reading and History at below-market rates. Built lean operations (onboarding, scheduling, payments reconciliation and curriculum logistics) while serving 2,500+ students and generating roughly $20,000 in revenue.
Co-founded a nonprofit research and advocacy network on adolescent substance-abuse awareness. Scaled a 14-person officer corps across 5 states and 3 countries, and collaborated with 10+ university professors and researchers from Harvard, Yale, USC and Johns Hopkins to inform research-backed policy advocacy.
Not screenshots and not recordings. Each panel below executes the real algorithm (the same consensus logic, the same graph search, the same closed-form attribution) as you scroll to it.
Starting cluster…
The stock engine ships two transports over the same RaftNode, and
neither can express message delay: the in-memory simulator's
_deliver invokes the recipient's handler synchronously and recurses,
so a RequestVote response can cascade through leadership election and
heartbeat fan-out inside one tick(). An in-flight message has no
state to hold a deadline in, and drop_rate is a single global
probability rather than per-edge.
So I wrote a third transport: a time-ordered priority queue of
(deliver_at, seq, sender, recipient, msg) against the unmodified
node API. Per-link drop_prob is rolled at send time to model packet
loss, while n-way partition membership and liveness are evaluated at
delivery time so a split kills packets already on the wire. Four
invariants are asserted every tick (election safety, leader completeness,
state-machine safety, and acknowledged-read consistency) with commitment
witnessed by quorum match_index advancement rather than by the
proposer's optimism. Cross-validating the queued transport against the engine's
own suite is what makes a reported violation attributable to the consensus
implementation and not to my harness.
The engine ships two transports over the same RaftNode: an in-memory
simulator and an asyncio TCP server. Neither can express message delay.
The simulator's _deliver invokes the recipient's handler synchronously
and recurses, so a vote response can trigger leadership, heartbeats, and their
responses all inside one tick(): an in-flight message has no state,
and “hold this for five ticks” has nowhere to live. Its drop_rate is
also a single global probability, not per-edge.
So I wrote a queued transport against the same node API, which the engine's own
docstring anticipates: a harness may “deliver it, delay it, or drop it.”
RaftNode is used completely unmodified.
| queue entry | (deliver_at, seq, sender, recipient, msg), ordered |
| base latency | 1 tick, nothing resolves inside the tick that produced it |
| per-link drop | rolled at send time, models packet loss |
| partition / liveness | evaluated at delivery time, models a split killing in-flight packets |
| election timeout | randomized 10–20 ticks; heartbeat every 3 |
Faults are independent objects consulted per message, so composition is structural
rather than special-cased. Partition supports n-way groups and several
simultaneous splits; the engine's own field holds a single two-group tuple.
LinkFault targets one directed edge with drop_prob and
delay_ticks, optionally bidirectional. “Crash a node during an active
partition” is simply two faults being live at once.
last_applied covers an acked write, reading that key from the leader returns that value.
A write counts as acknowledged only once the accepting leader's
commit_index covers it, the instant a real server would answer the
client. An uncommitted entry vanishing is correct Raft behaviour and is
recorded as an overwrite, never a durability violation.
A queued transport is a different code path from the engine's own 23 tests, so a violation could in principle be the harness's fault. Every scenario the engine's suite covers is re-run through the new transport with matching safety outcomes asserted. That cross-validation is what makes a reported violation attributable to the engine.
It earned its keep. A 600-seed randomized sweep flagged 50 violations under seed 124,
all false. An entry whose proposer was partitioned is only observed as committed
once that node rejoins, so index 3 was detected at tick 250 after index 4
was detected at tick 248; tracking the newest acked value per key in detection order
regressed the expectation to a value a later write had legitimately superseded.
Expected values are now keyed by log index, and commitment is witnessed by any live
node whose commit_index covers the entry. All three defects this
exercise surfaced were in the harness, and the report documents them rather than
hiding them.
Naive keyword matching flags any message containing an urgency word, with no regard for what the sentence actually means. Type something and compare it against the real model.
TF-IDF vectorization over 1–2 grams with sublinear_tf,
min_df=2 and L2 normalization across a 14,758-term vocabulary, into
logistic regression at C=4.0 with class_weight="balanced".
Linear by deliberate choice: for a linear model the Shapley values collapse to the
closed form φⱼ = wⱼ(xⱼ − E[xⱼ]) with base w·E[x] + b, so
base + Σφⱼ ≡ logit(x) holds exactly. No sampling, no KernelSHAP
approximation; a test asserts agreement with shap.LinearExplainer to
within 1e-8, which makes shap a test-only dependency and keeps serving
off any deep-learning stack at 107 MB resident.
The last mile is the harder part: contributions live on vocabulary features but the
highlight has to land on the characters the user actually typed. Tokens are matched
against the vectorizer's own token_pattern over the raw string and
normalized per token rather than per document, so unicode accent-stripping
cannot shift character offsets. Each bigram's φ is split across its two constituent
spans; any feature that fires but cannot be located is excluded from token scores and
reported as a residual, so the additive decomposition still reconciles to the logit.
This runs a stand-in model trained on the public Kaggle "Real or Not? NLP with Disaster Tweets" dataset, not the model from the NHSJS 2025 paper below, because that fine-tuned checkpoint was never available. Its accuracy is not comparable to the figures reported there, and it predicts whether text is disaster-related, not how urgent it is.
The four numbers above are this stand-in's own, measured on its own held-out split. The same disclosure is served by the API on every single response, so it travels with the output rather than living only on this page.
A fine-tuned transformer would score higher and explain worse. For a linear model the Shapley values have a closed form, so the attribution shown to the user is the exact contribution rather than a sampled estimate:
| SHAP value | φⱼ = wⱼ · (xⱼ − E[xⱼ]) |
| base value | w · E[x] + b |
| identity | base + Σφⱼ ≡ logit(x), exactly |
| verified against | shap.LinearExplainer, max abs difference < 1e-8 |
Two tests hold this in place: one asserts agreement with the reference implementation,
the other asserts the decomposition sums back to the model's logit over the wire. As
a consequence shap is a test-only dependency: serving needs no
deep-learning stack at all, and resident memory measures 107 MB.
| features | TF-IDF, 1–2 grams, sublinear_tf, min_df=2, L2-normalized, unicode accent stripping |
| classifier | logistic regression, C=4.0, class_weight="balanced" |
| vocabulary | 14,758 terms |
| data | 7,613 labelled examples, stratified 80/20 split |
| artifact | 0.55 MB, fits any free tier |
The interesting engineering is the last mile. Contributions live on vocabulary
features, but the highlight has to land on characters the user typed. Tokens are
matched on the raw string with the vectorizer's own token_pattern and
normalized per token rather than per document, so accent stripping cannot
shift the character offsets. Each bigram's contribution is then split across its two
constituent spans. Any feature that fires but cannot be located stays out of the
token scores and is reported as a residual, so the additive identity above still
holds exactly.
The demo runs a stand-in model trained on public Kaggle data, because the original research checkpoint was unavailable. That disclosure is served by the API on every response and rendered on the page, so it cannot be quietly dropped by an embedder. The metrics quoted here are the stand-in's own, and reproducible.
On “This new album is an absolute disaster lol” the token disaster
contributes +0.83 toward disaster-related, and the verdict is still
not disaster-related at 82%, because new (−0.85) and
lol (−0.55) outvote it. The label alone tells you nothing about that.
A node's position on screen is its vector, so the highlighted
path is the actual geometry _search_layer navigates.
Click the sparse top layer to drop a query.
A hand-written hierarchical navigable small-world index: M=16,
M_max0 = 2M at the base layer, ef_construction=200, cosine
distance over L2-normalized 384-dim vectors from an ONNX-exported
all-MiniLM-L6-v2 with attention-masked mean pooling. Because the vectors
are normalized, cosine reduces to a dot product, which is what keeps greedy traversal
cheap. Layer assignment is the paper's exponential decay
(⌊−ln(U) · mL⌋), and search descends greedily at ef=1 per
layer before a bounded best-first SEARCH-LAYER at layer 0.
Insertion uses SELECT-NEIGHBORS-HEURISTIC (Algorithm 4), not the simple
nearest-M rule. A candidate is rejected when it sits closer to an already-selected
neighbor than to the query, which preferentially retains non-redundant candidates and
forces the long-range bridge edges the upper layers depend on for expected
O(log n) search; keepPrunedConnections backfills if the
diversity constraint under-fills the neighbor list. Without it the graph collapses
into per-cluster islands. Deletes are tombstoned rather than excised, since removing
a node can sever connectivity that neighbouring searches traverse through.
Recall is by meaning, not keyword, so it needs real embeddings and a real vector index. Rather than calling a hosted embedding API, both run on the machine: a hand-written HNSW (hierarchical navigable small world) graph over vectors produced by an ONNX-exported MiniLM.
| index | HNSW, M=16, ef_construction=200, cosine metric |
| embedder | all-MiniLM-L6-v2 via ONNX Runtime, 384-dim |
| pooling | attention-masked mean pool, then L2 normalization |
| runtime cost | onnxruntime + tokenizers ≈ 90 MB, against ~2 GB for a PyTorch stack |
| persistence | vectors as .npz, records as JSON, tombstoned deletes |
| network calls | 0 |
Inserting a node means picking up to M neighbors from the candidates
_search_layer found. The paper's simple rule (take the M
closest) sounds sufficient and isn't: for a node deep inside a tight cluster, its
M nearest candidates are almost always from that same cluster, so nothing
ever forces a long-range edge to a different region of the space. The graph
fragments. SELECT-NEIGHBORS-HEURISTIC instead rejects a candidate if it is
farther from the query than it is from a neighbor already picked, which
preferentially keeps candidates that aren't redundant with what's already selected.
On Gaussian-cluster test data this was the difference between ~5% of nodes reachable
from the entry point and >95% connectivity at the same parameters.
Local-first is the design constraint, not a limitation: memory contents are exactly the material you least want to hand to a third-party embedding endpoint.
The visualizer above shows the index's internals; this is the tool interface a session actually calls.
# session one, months ago store_memory( text="We picked Postgres over MySQL because we need JSONB indexing", tags=["decision", "db"] ) # session two, different machine, different day search_memory("why did we not use mysql") → "We picked Postgres over MySQL because we need JSONB indexing" matched by meaning, not by any shared keyword
National High School Journal of Science · Peer-Reviewed
A published, peer-reviewed paper benchmarking modern transformer architectures against classical statistical baselines for humanitarian crisis intelligence. Mentored by Dr. Chris Irwin Davis, PhD, at UT Dallas.
Fine-tuned a pretrained BERT transformer on 10,000+ disaster-related tweets spanning wildfires, hurricanes and floods, using domain-specific tokenization, subword regularization and class-weighted cross-entropy to combat severe label imbalance.
Architected a controlled three-way benchmark (BERT vs. TF-IDF + logistic regression vs. multinomial Naïve Bayes) under identical stratified k-fold cross-validation and held-out test splits, isolating architectural contribution from data leakage.
Achieved 89.3% test accuracy and an F1 of 0.88, outperforming the strongest classical baseline by 21% and validating transformer transfer learning as a deployable primitive for real-time humanitarian triage.
Conducted independent error analysis exposing a sharp accuracy collapse on sarcastic and semantically ambiguous text; engineered inverse-frequency class weighting and contextualized embedding-space oversampling to lift minority-class recall by 2.1% and F1 by 1.7%.
Authored the manuscript end to end, defended it through NHSJS peer review, and published the full methodology and code as an open-source repository for reproducibility.
The figures above are those reported in the NHSJS publication. The interactive demo in Live Systems is a separate model trained on public data so the attribution layer is explorable without the original checkpoint; it measures 0.8024 accuracy on its own held-out split. The two are not comparable.
During an active disaster the inbound volume of social posts vastly exceeds what responders can read, and the messages that matter (trapped persons, structural collapse, medical need) are diluted by commentary, metaphor and reshares. Framed as supervised text classification, the difficulty is that the vocabulary of urgency overlaps heavily with the vocabulary of ordinary hyperbole, so surface keyword matching fails precisely where accuracy matters most.
| base model | bert-base-uncased, sequence classification head |
| max sequence | 128 tokens, padded and truncated |
| optimizer | AdamW, learning rate 2e-5 |
| batch size | 16 per device |
| epochs | 5, best checkpoint by eval loss |
| seed | 42 |
Macro-averaged precision, recall and F1 alongside a confusion matrix and ROC/AUC over softmax probabilities for the positive class, macro rather than micro because the urgent class is the minority, and micro-averaging would let majority-class performance mask exactly the failure mode that matters. The transformer is measured against a TF-IDF/Naive-Bayes baseline.
Two distinct models appear on this page. The 89.3% / F1 0.88 figures above
are those reported in the NHSJS publication. The interactive demo in section 01 is
a separate model trained on public data so the explanation layer is explorable
without the original checkpoint; its 0.8024 is measured on its own held-out
split and served live from its /metrics endpoint. The two are not
comparable: different models, different data.
Harvard University · under Professor David Kane, a Harvard preceptor
Shipping production-grade R infrastructure and Quarto-based curricula used by an internationally distributed collegiate data-science bootcamp.
Engineered production-grade R packages with proper NAMESPACE hygiene, unit tests, roxygen2 documentation and semantic versioning, deployed into a reproducible research toolchain used by students across multiple countries.
Authored Quarto-based pedagogical modules integrating literate programming, executable code blocks, LaTeX-rendered math and reproducible HTML/PDF outputs, bridging pedagogy and research reproducibility in a single artifact.
Developed Bayesian statistical pipelines (priors, likelihoods, posterior sampling and credible-interval reporting), abstracting the mechanical parts of probabilistic modelling so downstream learners focus on inference intuition.
Resolved a critical defect in a shared library that carried no prior documentation or guidance, unblocking the international bootcamp curriculum and demonstrating independent systems-level debugging.
Contributed 10+ hours per week to an open, versioned curriculum shipped into a live international bootcamp, with feedback loops from real students informing iterative library refactors.
UT Dallas · NLP with Python · under Dr. Chris Irwin Davis, PhD
An eight-week research immersion building Python NLP pipelines end to end (tokenization, embedding generation and model fine-tuning) for real-world text classification across multiple domains. This is the work that became the peer-reviewed publication above.
USA Cricket U19 West Conference Team · Captain · 2021–present
Selected for the USA Cricket U19 West Conference Team through multi-stage national tryouts, ranked 31st nationally among 200,000+ competitive players, 1st in the Southwest Region and 2nd in the Dallas Region.
Selected through multi-stage national tryouts and appointed Captain, leading squad strategy, training and competition execution.
Ranked 31st nationally among 200,000+ competitive U19 players, 1st in the Southwest Region and 2nd in the Dallas Region, with a career record of 96 matches, 1,396 runs and 62 wickets.
Founded the Coyote Cricket Club at Heritage HS from nothing in a school with no prior program, growing it to 25–30 students and leading it to consecutive top finishes in an 18-school interdistrict tournament: two 2nd-place results and a 3rd.
Balanced high-performance athletics with research, USACO Gold, nonprofit leadership and a full academic load; elite sport and elite systems work compounding rather than competing.
Science Olympiad: President, Treasurer and four-year competitor across Entomology, Dynamic Planet, Remote Sensing and Helicopter, top 3 of 16 teams at Regionals twice · Mind4Matter: Global Outreach Representative for a student-run mental-health nonprofit spanning 10 chapters and 1,500+ volunteers · Karya Siddhi Hanuman Temple: 120+ hours directing kitchen operations for large-scale community celebrations.
From national athletics to USACO Gold, peer-reviewed research, and global top-100 investment rankings.
| Aug 2026 | Claude in Code, Anthropic Academy. Deploying Claude Code as an autonomous engineering agent: explore-plan-code-commit, context management, project-level instructions and hooks. |
| Aug 2026 | Model Context Protocol: Advanced Topics, Anthropic Academy. Architecting MCP servers and clients across tools, resources and prompts. |
| Jul 2026 | Software Engineer Intern, HackerRank. Timed assessment across problem-solving and SQL. |
| Jun 2026 | Frontend Developer (React), HackerRank. Component architecture, state, routing, ES6. |
| May 2026 | IT Specialist in Java, Certiport / Pearson. Performance-based OOP, data structures, debugging. |
| May 2025 | Cybersecurity Fundamentals, NOCTI. Cryptography, threat analysis, authentication, digital forensics. |
| Mar 2025 | Java Coding Specialist, Knowledge Pillars. |
| graduating | May 2027 |
| school | Heritage High School, Frisco TX |
| languages | Python, R, Java, JavaScript, SQL, HTML; C (introductory) |
| frameworks | React, FastAPI, Angular, NumPy, Pandas, Quarto, Google OR-Tools, asyncio, Go |
| tools | Git/GitHub, MCP, Claude Code, VS Code, Linux/Unix |
Listening on three channels. Response time is measured in hours, not weeks.