❯Arin Mallanna Tumbagi — Software Engineer, Saviynt · B.Tech, IIT Madras

Slow enterprise systems, made fast. AI agents that show receipts.

./view_work

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

◆LeetCode Guardian · peak 2077◆Codeforces Expert · 1602◆Meta Hacker Cup · Round 2◆Maven Central · s3-outputstream v2.0.0◆OpenSearch · merged PR◆IIT Madras · JEE top 0.2%◆identity governance · 300+ tenants◆2× company-wide Tiger Team◆LeetCode Guardian · peak 2077◆Codeforces Expert · 1602◆Meta Hacker Cup · Round 2◆Maven Central · s3-outputstream v2.0.0◆OpenSearch · merged PR◆IIT Madras · JEE top 0.2%◆identity governance · 300+ tenants◆2× company-wide Tiger Team
$ cat intro.txt

I work on identity governance — 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: Guardian (peak 2077) / Expert 1602. Current interests: consensus and storage, transformers and inference.

$ start here · 60 seconds

Three things to know

01The audit check that ran all day~20h → minutes+

A compliance workload that ran overnight now finishes before lunch.

One large enterprise check re-examined the company hierarchy once per rule — thousands of redundant passes over 65 GB. Now the hierarchy resolves a single time and permissions compare 64 people per processor instruction. Under ~1 GB, with matching violations. full write-up →

02Exports that can't crash the server5 MiB · any size+

Reports that used to run out of memory now stream straight to storage.

s3-outputstream (Apache-2.0, v2.0.0 on Maven Central): formatted Excel flows through one reusable 5 MiB part buffer. An upload publishes only when the producer declares success — otherwise it is discarded. A 1 KB file and a 10 GB file use the same memory. full write-up →

03AI investigators that show receiptscited or silent+

Software agents that prove each claim against source data — or hand the case to a human.

Bounded investigator agents pursue one fraud hypothesis with strict step and time budgets. Every cited log entry is re-checked against the source; uncertain findings route to a reviewer. Public harness: 110 tests, 46/46 held-out variants, zero unsupported claims. see the system →

plain words first · engineering inside — click any row

$ ls ./production

Production systems

Internal systems at Saviynt, shown through numbers and write-ups. Personal work links out to code.

all seven →
01 · LICENSE INTELLIGENCErecommendation engine

License waste, found and priced

Finds SAP accounts you're overpaying for, with the dollar amount attached.

+ how it works

Companies pay SAP per user, priced by access level. Most quietly overpay for dormant accounts and over-privileged users. I built the recommendation engine that finds this waste: findings computed live from the search index at request time, priced in dollars, acted on through one action call that fans out into removal tasks with de-duplication. Action records live on the identity document and survive the nightly data replacement through merge/strip/prune. Validated 51/51 against live APIs in test, through two rounds of senior review; a test tenant showed seven findings worth about $11,000 a year. Test result, not a production savings claim — the dollar math scales with estate size.

JavaSpring BootKafka AvroOpenSearch
02 · COMPLIANCE ENGINE~20h → mins

A day-long audit check, rebuilt to minutes

A compliance check that ran overnight now finishes before lunch.

+ how it works

Large companies must continuously prove that no employee holds conflicting permissions. For example, the ability to both create and approve the same payment. For one large enterprise production workload, this check took about 20 hours at 65 GB 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. The redesigned path runs in a few minutes under about 1 GB, with matching violations across the rollout comparisons. Worst-case production scope, not a lab benchmark.

JavaRaw JDBCBitSetOpenSearch
03 · DATA EXPORT5 MiB buffer · v2.0.0

Excel exports that stream to S3

Reports of any size, without ever running out of memory.

+ how it works

Audit and compliance teams periodically need complete data exports as formatted Excel workbooks in S3. The previous exporter assembled entire workbooks in memory and crashed on large reports. I built s3-outputstream, an Apache-2.0 Java OutputStream over S3 multipart with one reusable 5 MiB part buffer: an upload publishes only when the producer declares success, otherwise it is discarded. v2.0.0 is on Maven Central with a real-S3 conformance receipt. Bounded application buffering, not bounded total process memory — producer, SDK and per-part overhead are separate budgets.

JavaPOI SXSSFS3 multipartZIP streaming
04 · AI SAFETY5 patterns · deterministic

The same fraud check, for AI agents

Dangerous permission combos, now policed in AI assistants too.

+ how it works

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 formulated effective access for agents across five patterns — a single over-privileged agent, conflicts spanning agent and owner, delegation chains, credential-sharing groups, actions on a user's behalf — and built a deterministic evaluation engine where every finding cites its evidence and is tracked to resolution. Latency and deployment scope stay out until measured and cleared.

JavaSpring BootGraph analysisRaw JDBC
$ ls ./ai-systems

AI systems

The same discipline applied to models and inference: budgets, bounds, and evidence.

write-ups →
AI INFRASTRUCTURE

Send each request where its past already lives

less recomputation

A load balancer that remembers which server already knows you.

+ how it works

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.

LEARNING IN PUBLIC

A language model built by hand

no model libraries

Learn transformers by rebuilding one — then twice more, deeper.

+ how it works

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.

LEARNING IN PUBLIC

The same model, one level deeper

in progress

The same transformer, now in raw GPU code.

+ how it works

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.

$ ./export --watch

Bounded at every stage.

Five stages, each with a hard memory bound. The export never holds the whole workload — so a 1 KB file and a 10 GB file cost the same.

scroll to walk the stages

01
read≤ one page

The database is asked for one page of rows at a time. Each page is processed, released, and forgotten before the next arrives.

02
format≤ 50-row window

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

03
upload≤ 5 MB parts

Finished workbooks stream to object storage in fixed 5 MB parts. A 1 KB file and a 10 GB file use the same buffer.

04
archive≤ streamed zip

Workbooks are read back in small chunks and zipped on the fly. The final archive is never assembled whole.

05
deliver≤ one key

A single object lands in storage. The S3 stage holds one 5 MiB part buffer; producer, SDK and per-part overhead are separate budgets.

stage bounds from the production design; the write-up documents failure behavior and the real-S3 conformance receipt.

$ ask anything

Ask the site

Semantic search over everything here, judged by calibrated AI. It cites its page — or tells you it doesn't know.

full terminal →
guest@arin: ~/askLIVE
$ cat open_questions.txt

What I'm trying to learn next

Four open threads, each anchored to production experience. Updated when one closes.

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.

$ ls ./open-source

Open source

all repos
~20h → mins
compliance check, rebuilt
large-enterprise worst case · <1 GB memory
5 MiB
buffer for exports of any size
explicit commit semantics · v2.0.0 on Maven Central
110
tests on the agent harness
46/46 held-out variants · zero unsupported claims
2 s
engine compute on 100K+ accounts
bit-level comparison · published with approval
$ tail -f ~/github

Live from GitHub

highlights →
$ git log --oneline

How I got here

01

SWE @ Saviynt

Jun 2025 → now · identity governance

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

02

B.Tech Ocean Eng, IIT Madras

2021 → 2025 · JEE top 0.2% of 1.1M

Math, modeling, physics. Plus Team Abhiyaan (2023 pitches to India's Finance and Commerce Ministers) and IITM football.

03

Competitive programming

4 years · Guardian (peak 2077) · Expert 1602 · Meta Hacker Cup R2

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

04

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

Building something where these systems matter?

Questions about this work, research conversations, or collaboration — email is the fastest way to reach me.