Arin Mallanna Tumbagi

Software Engineer, Saviynt · B.Tech, IIT Madras

Systems that hold up under heavy load. Agents that stand behind their claims.

./view_work

guest@arin:~LIVE

// good evening, guest — my time 23:32 IST

$ whoami

arin.mallanna — software engineer @ saviynt

$ cat focus.txt

backends that stream · agents that cite evidence

$ cat interests.txt

consistency · storage · transformers · inference

~❯

sod_eval: 2s compute · ~3 min w/ writes → was 21h

fraud_agent: 0 unverified claims · below 0.70 → human

click inside and type `help` · all figures from production systems

scroll

$ cat intro.txt

The short version

I work on identity governance. That is the software that controls who inside a large company can access what. My systems move records at any scale, and my agents work under strict budgets with checked outputs. I studied Ocean Engineering at IIT Madras and spent four years on competitive programming: LeetCode Guardian 2100+ / Codeforces Expert 1602. Current interests: consensus and storage, transformers and inference.

21h → ~3 min

2 s of it compute

No upper bound

7MB flat · 15M+ proven

5 risk patterns

~22ms a check

≈400×

compliance check

21h → ~3 min · compute is 2 s

7 MB

flat at any scale

15M+ rows proven · no upper bound

50K+/s

audit events

none lost, none double-counted

live

license inference

any accounts · unbounded findings

2100+

LeetCode peak

Codeforces Expert · Hacker Cup R2

300+

enterprise tenants

AWS · Azure · GovCloud

$ ./export --watch

The 7 MB pipeline, running

rows 0 · mem 7.0 MB

02 · format≤ 50-row window in memory

Cells are written through a 50-row sliding window. Older rows spill to temporary disk. Never to memory.

looped demonstration. The architecture is the production one. full write-up · the 5 MB primitive didn't exist in the AWS toolkit, so I built it: s3-outputstream

$ ls ./production

Production systems

run the 2-minute audit →full story →

LICENSE INTELLIGENCE· internal systemlive inference

License waste, found and removed

Companies pay SAP per user, priced by access level. Most quietly overpay for dormant accounts and over-privileged users. I built the inference engine that finds this waste. It reads access data and infers savings opportunities, any number of accounts or identities, with dollar figures attached. Then it acts on them, creating removal tasks with records that survive the nightly data refresh. Validated 51/51 against live APIs, through two rounds of senior review.

JavaSpring BootKafka AvroOpenSearch

COMPLIANCE ENGINE· internal system21h → ~3 min

A day-long audit check, rebuilt to seconds

Large companies must continuously prove that no employee holds conflicting permissions. For example, the ability to both create and approve the same payment. Running this check across hundreds of thousands of accounts took one customer 21 hours, because the old system re-examined the organization hierarchy separately for every rule. I rebuilt the engine to resolve the hierarchy once and compare permissions with bit-level operations. Compute fell to 2 seconds in 256 MB, and with database writes the whole job now finishes in about 3 minutes. Output identical, row for row.

JavaRaw JDBCBitSetOpenSearch

DATA EXPORT· internal systemunbounded · 7 MB flat

Million-row reports that fit in 7 MB

Audit and compliance teams periodically need complete data exports. Millions of rows formatted as Excel workbooks. The previous exporter assembled entire workbooks in memory and crashed on large reports, typically during audit season. I rebuilt it as a pipeline where each stage handles only a small window of data at a time. It reads, formats, uploads, and archives in a continuous flow, so memory stays flat at 7 MB. 15M+ rows proven in production, with no upper bound in the design.

JavaPOI SXSSFS3 multipartZIP streaming

AI SAFETY· internal system~22ms per check

The same fraud check, for AI agents

Companies now build AI assistants that hold tools, data access, and login credentials. These assistants can call other assistants or share credentials with them. The dangerous permission combinations we police in humans quietly reappear, with no person in the loop. I built an engine that examines each agent setup for five such patterns. A single over-privileged agent, conflicts spanning an agent and its owner's permissions, delegation chains between agents, credential-sharing groups, and actions taken on a user's behalf. Each setup evaluates in about 22 milliseconds, and every finding is tracked until it is resolved.

JavaSpring BootGraph analysisRaw JDBC

all seven production systems →

$ ls ./ai-systems

AI systems

write-ups →

AI INFRASTRUCTURE

Send each request where its past already lives

less recomputation

When you continue a conversation with a large language model, the serving computers keep a cache of what came before, so follow-up questions avoid redoing work. But in a fleet of machines, a standard load balancer sends your follow-up to a random server, which recomputes everything. Nostos, a router I built, instead sends each request to the server whose cache already holds that conversation. It weighs cache overlap against queue length and memory load. It remembers fingerprints of past text, never the text itself, and passes responses through without buffering. A public demo lets you race routing strategies against each other.

GoRadix treesvLLM / TGIReact

LEARNING IN PUBLIC

A language model built by hand

no model libraries

To understand language models from the inside, I implemented a small one in PyTorch while deliberately refusing the framework's ready-made model components. Embeddings, attention, and decoder blocks all written out explicitly, each stage tested before the next. The model is tiny on purpose, so that internal quantities like the attention matrix stay small enough to read directly. Since ported to dependency-free C++17 as gpt2-cpp, with a five-test correctness harness. And since trained for real as lm-train: 0.818M params on Shakespeare, val loss 1.75.

PythonPyTorchTransformerspytest

LEARNING IN PUBLIC

The same model, one level deeper

in progress

Now the same transformer implemented directly in the graphics processor's own programming language, with every computation kernel written by hand. It starts from matrix multiplication checked against an ordinary CPU reference, moves through attention and normalization, and heads toward a full training run and an optimized attention variant benchmarked against PyTorch. The goal is a working understanding of how GPUs actually execute programs. Memory movement, parallel scheduling, occupancy. Not familiarity with an API, but with the machine. In progress; each phase must pass its tests before the next begins.

CUDAC++CPU referenceColab T4

$ cat open_questions.txt

What I'm trying to learn next

01 — consistency, now with running code

My ingestion pipeline behaves exactly once in practice. Idempotent storage, ordered partitions, careful retries. Since writing this I implemented Raft in C++ — election, replication, a KV machine, chaos-tested across seeds. Remaining: membership changes, snapshots, and deriving my own pipeline's guarantees from first principles rather than the next incident.

02 — storage engines I've only consumed

I sit on top of OpenSearch and MySQL every day and tune around their behavior. Page sizes, merge pressure, compaction stalls. I've never built the LSM-tree or B-tree underneath, and I want to understand the layer I currently treat as weather.

03 — verification instead of vigilance

Right now correctness at scale means parallel runs, automated diffs, and dashboards I check compulsively. It works, but it's vigilance, not proof. I want the formal-methods background to specify what a pipeline guarantees and verify it holds, before production finds out.

04 — serving intelligence cheaply

My router treats cached conversation as a resource worth scheduling around. But batching, eviction, and heterogeneous hardware underneath are subjects I've only read about. Serving is where AI systems meet operating systems, and I want the scheduling and architecture theory beneath the API I've already built on.

4 open threads · updated when one closes

$ ls ./open-source

Open source

all repos

$ beyond my own repos

❯s3-outputstream — the S3 streaming primitive the AWS toolkit never shippedshipped ❯kirodotdev/KiroCrewcontribution ❯EleutherAI/lm-evaluation-harnesscontribution ❯sgl-project/sglangcontribution ❯opensearch-project/OpenSearch● merged ❯opensearch-project/opensearch-gocontribution

s3-outputstream

Lets Java programs write data of any size to cloud storage using a fixed 5 MB of memory, instead of buffering everything first.

JavaFills a 4-year gap in the AWS toolkit

mica

A glass desktop markdown app. Your vault is a folder of .md files: two panes, slash commands, wikilinks, command palette, offline. Tauri 2, dark by default, with a live landing page and a Mac release.

TypeScriptlive landing + signed DMG

gpt2-cpp

GPT-2 in dependency-free C++17: tensor core to greedy decode in seven commits, verified by five correctness tests. No frameworks, no BLAS.

C++causality proven, not assumed

lm-train

The missing run: 0.818M-param char GPT trained end to end on Shakespeare. Loss curves, checkpoint samples, reproduce command.

Pythonval loss 1.75, committed

raft-cpp

Raft consensus in dependency-free C++17: election, replication, KV machine, chaos-tested across seeds. Simulated transport, documented honestly.

C++single-leader safety, proven

context-lattice

Gives AI coding assistants a searchable memory of past work where every recalled fact links back to its source file and a cryptographic fingerprint.

PythonEvery recall cites its source

$ tail -f ~/github

Live from GitHub

highlights →

$ tail -f ./notes

Notes from production

all posts →

PLATFORM2026-08-25 · 15 min

Unused permissions, priced in dollars

A license-saving feature end to end: live-computed findings, one action that becomes removal tasks, and action records engineered to survive the nightly data refresh.

read_post →

INFERENCE2026-02-10 · 14 min

Route to the machine that already knows the conversation

Most AI serving cost is re-reading conversations a computer has already seen. Nostos sends each request where its past already lives, and a public arena lets you race routing strategies against each other.

read_post →

ML2026-01-18 · 13 min

A language model from scratch, three times

The same transformer at three levels: PyTorch with no shortcuts, dependency-free C++ with tests green, raw GPU code in progress. What changes each time you rebuild it.

read_post →

$ git log --oneline

How I got here

SWE @ Saviynt

Jun 2025 → now · identity governance · 300+ tenants

Own export pipeline, SoD engines, audit ingestion, agent safety. 2× Tiger Team.

B.Tech Ocean Eng, IIT Madras

2021 → 2025 · JEE top 0.2% of 1.1M

Math, modeling, physics. Plus Team Abhiyaan (pitched to India's Commerce Minister) and football, chess, cricket at district level and above.

Competitive programming

4 years · Guardian 2100+ · Expert 1602 · HackerCup R2

My department offered no CS courses, so I trained against students who had them, and stayed until my rankings matched theirs.

ML from first principles

ongoing · in public

A language model by hand, then in dependency-free C++, then in raw GPU code. Detection models, heuristic search, evolutionary optimization. I learn a system by rebuilding it.

the contest archive behind the ratings. Searchable: ~/dsa →

$ ./open_channel

Get in touch.

For questions about this work, research conversations, or collaboration. Email is the fastest way to reach me.

resume.pdf ↓github/Arin016 linkedin